package render

import (
	"encoding/xml"
	"math"
	"regexp"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/lukaszkasprzak/prognosis/internal/openmeteo"
)

// svgView builds hours starting at 12:00, so a 24-hour view crosses midnight.
func svgView(hours int) View {
	v := View{Label: "Krakow, PL", Sun: map[string][2]string{}}
	start := time.Date(2026, 8, 27, 12, 0, 0, 0, time.UTC)
	for i := 0; i < hours; i++ {
		when := start.Add(time.Duration(i) * time.Hour)
		v.Rows = append(v.Rows, openmeteo.Row{
			When: when,
			Code: 3,
			Vals: map[string]float64{
				"temperature_2m":            15 + 6*math.Sin(float64(i)/4),
				"apparent_temperature":      14 + 6*math.Sin(float64(i)/4),
				"precipitation":             float64(i%7) * 0.1,
				"precipitation_probability": float64(i % 100),
				"relative_humidity_2m":      50 + float64(i%40),
			},
		})
		v.Sun[when.Format("2006-01-02")] = [2]string{"05:47", "19:35"}
	}
	return v
}

func svgOf(t *testing.T, hours int) string {
	t.Helper()
	out := SVG(svgView(hours), testConfig())
	if out == "" {
		t.Fatal("SVG produced nothing")
	}
	return out
}

func TestSVGIsWellFormedXML(t *testing.T) {
	out := svgOf(t, 24)
	if err := xml.Unmarshal([]byte(out), new(any)); err != nil {
		t.Fatalf("not well-formed XML: %v", err)
	}
	if !strings.HasPrefix(out, "<svg xmlns=") {
		t.Error("missing the SVG namespace, so viewers will refuse it")
	}
}

// A place name is user input and can carry characters XML reserves.
func TestSVGEscapesTheLabel(t *testing.T) {
	v := svgView(6)
	v.Label = `Foo & <Bar>`
	out := SVG(v, testConfig())
	if strings.Contains(out, "<Bar>") || strings.Contains(out, "& ") {
		t.Errorf("label was not escaped:\n%s", out)
	}
	if err := xml.Unmarshal([]byte(out), new(any)); err != nil {
		t.Fatalf("unescaped label broke the XML: %v", err)
	}
}

func TestSVGEmptyViewProducesNothing(t *testing.T) {
	if got := SVG(View{}, testConfig()); got != "" {
		t.Fatalf("expected empty output for no rows, got %d bytes", len(got))
	}
}

// One point per hour, on every series.
func TestSVGSeriesHaveAPointPerHour(t *testing.T) {
	const hours = 18
	out := svgOf(t, hours)
	polylines := regexp.MustCompile(`<polyline points="([^"]+)"`).FindAllStringSubmatch(out, -1)
	if len(polylines) < 4 {
		t.Fatalf("expected at least four series, found %d", len(polylines))
	}
	for i, m := range polylines {
		if n := len(strings.Fields(m[1])); n != hours {
			t.Errorf("series %d has %d points, want %d", i, n, hours)
		}
	}
}

// Night shading is what makes a meteogram readable; without sun data there must
// be none rather than a guess.
func TestSVGNightBandsFollowSunData(t *testing.T) {
	withSun := svgOf(t, 24)
	if !strings.Contains(withSun, `fill="#eef1f6"`) {
		t.Error("no night bands drawn despite sunrise/sunset being known")
	}
	v := svgView(24)
	v.Sun = map[string][2]string{}
	if strings.Contains(SVG(v, testConfig()), `fill="#eef1f6"`) {
		t.Error("night bands drawn without sun data; that is a guess")
	}
}

func TestIsNight(t *testing.T) {
	sun := map[string][2]string{"2026-08-27": {"05:47", "19:35"}}
	at := func(h int) time.Time { return time.Date(2026, 8, 27, h, 0, 0, 0, time.UTC) }
	for _, c := range []struct {
		hour int
		want bool
	}{{0, true}, {5, true}, {6, false}, {12, false}, {19, false}, {20, true}, {23, true}} {
		if got := isNight(at(c.hour), sun); got != c.want {
			t.Errorf("%02d:00 night=%v, want %v", c.hour, got, c.want)
		}
	}
	// An unknown date must not be shaded on a guess.
	if isNight(time.Date(2030, 1, 1, 3, 0, 0, 0, time.UTC), sun) {
		t.Error("shaded a date with no sun data")
	}
}

// The rain panel carries millimetres and percent. Without the right-hand axis
// the dashed probability line is read against the millimetre scale.
func TestSVGRainPanelHasBothAxes(t *testing.T) {
	out := svgOf(t, 24)
	if !strings.Contains(out, "100%") || !strings.Contains(out, "50%") {
		t.Errorf("no percentage axis for the probability line:\n%s", out)
	}
}

func TestSVGDatesAreBoldAndHoursDoNotCollide(t *testing.T) {
	out := svgOf(t, 30) // crosses midnight
	if !strings.Contains(out, `font-weight="bold"`) {
		t.Error("date labels are not bold")
	}

	// Collect the x of every axis label, and check none sits on top of a date.
	type label struct {
		x    float64
		bold bool
	}
	var labels []label
	re := regexp.MustCompile(`<text x="([0-9.]+)" y="\d+" text-anchor="middle"( font-weight="bold")?`)
	for _, m := range re.FindAllStringSubmatch(out, -1) {
		x, _ := strconv.ParseFloat(m[1], 64)
		labels = append(labels, label{x: x, bold: m[2] != ""})
	}
	if len(labels) < 4 {
		t.Fatalf("expected several axis labels, found %d", len(labels))
	}
	for _, a := range labels {
		if !a.bold {
			continue
		}
		for _, b := range labels {
			if !b.bold && math.Abs(a.x-b.x) < 20 {
				t.Errorf("an hour label at x=%.0f collides with the date at x=%.0f", b.x, a.x)
			}
		}
	}
}

func TestSVGHasALegendForTheTwoTemperatureSeries(t *testing.T) {
	out := svgOf(t, 12)
	if strings.Count(out, ">temp<") == 0 || strings.Count(out, ">feels<") == 0 {
		t.Errorf("the dashed series is unexplained without a legend:\n%s", out)
	}
}

func TestSVGDrawsDayBoundaries(t *testing.T) {
	crossing := svgOf(t, 30)
	if !strings.Contains(crossing, `stroke="#9aa3ad"`) {
		t.Error("no midnight rule drawn on a view that crosses midnight")
	}
	if strings.Contains(svgOf(t, 6), `stroke="#9aa3ad"`) {
		t.Error("midnight rule drawn on a six-hour view that never reaches midnight")
	}
}

// Axis labels must land on round numbers, and the count must follow the step.
func TestNiceTicks(t *testing.T) {
	for _, c := range []struct{ lo, hi float64 }{{9.4, 22.6}, {0, 1}, {-4.2, 3.1}, {990, 1030}} {
		lo, hi, lines := niceTicks(c.lo, c.hi, 6)
		if lo > c.lo || hi < c.hi {
			t.Errorf("niceTicks(%v,%v) = %v,%v — must contain the range", c.lo, c.hi, lo, hi)
		}
		if lines < 2 || lines > 8 {
			t.Errorf("niceTicks(%v,%v) wants %d lines", c.lo, c.hi, lines)
		}
		step := (hi - lo) / float64(lines-1)
		for i := 0; i < lines; i++ {
			v := lo + step*float64(i)
			if math.Abs(v-math.Round(v*100)/100) > 1e-9 {
				t.Errorf("tick %v is not a round value", v)
			}
		}
	}
}

// The meteogram needs its own fields whatever the table shows.
func TestSVGFieldsCoverEveryPanel(t *testing.T) {
	for _, f := range []string{
		"temperature_2m", "apparent_temperature", "precipitation",
		"precipitation_probability", "relative_humidity_2m",
	} {
		found := false
		for _, have := range SVGFields {
			if have == f {
				found = true
			}
		}
		if !found {
			t.Errorf("SVGFields is missing %q, so that panel would be empty", f)
		}
	}
}