package logo

import (
	"bytes"
	"image"
	"image/color"
	"image/png"
	"strings"
	"testing"
)

func TestScaleKeepsAspect(t *testing.T) {
	wide := solid(800, 400, color.NRGBA{R: 20, G: 80, B: 200, A: 255})
	out, mime, err := Normalize(wide)
	if err != nil {
		t.Fatal(err)
	}
	if mime != "image/png" {
		t.Fatal(mime)
	}
	w, h, err := SizeOf(out)
	if err != nil {
		t.Fatal(err)
	}
	if w != 512 || h != 256 {
		t.Fatalf("wide %dx%d", w, h)
	}
	tall := solid(100, 600, color.NRGBA{G: 180, A: 255})
	out, _, err = Normalize(tall)
	if err != nil {
		t.Fatal(err)
	}
	w, h, err = SizeOf(out)
	if err != nil {
		t.Fatal(err)
	}
	if h != 512 || w > 512 || w < 80 {
		t.Fatalf("tall %dx%d", w, h)
	}
	small := solid(40, 40, color.NRGBA{B: 255, A: 255})
	out, _, err = Normalize(small)
	if err != nil {
		t.Fatal(err)
	}
	w, h, _ = SizeOf(out)
	if w != 40 || h != 40 {
		t.Fatalf("small %dx%d", w, h)
	}
}

func TestSVG(t *testing.T) {
	ok := []byte(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"><circle cx="5" cy="5" r="4" fill="#1f6feb"/></svg>`)
	out, mime, err := Normalize(ok)
	if err != nil || mime != "image/svg+xml" || !bytes.Equal(out, ok) {
		t.Fatalf("%s %v %d", mime, err, len(out))
	}
	bad := []byte(`<svg xmlns="http://www.w3.org/2000/svg"><script>alert(1)</script></svg>`)
	if _, _, err := Normalize(bad); err == nil {
		t.Fatal("script svg")
	}
	huge := []byte("<svg xmlns=\"http://www.w3.org/2000/svg\">" + strings.Repeat("a", MaxSVG) + "</svg>")
	if _, _, err := Normalize(huge); err == nil {
		t.Fatal("grote svg")
	}
}

func solid(w, h int, c color.NRGBA) []byte {
	img := image.NewNRGBA(image.Rect(0, 0, w, h))
	for y := 0; y < h; y++ {
		for x := 0; x < w; x++ {
			img.SetNRGBA(x, y, c)
		}
	}
	var buf bytes.Buffer
	_ = png.Encode(&buf, img)
	return buf.Bytes()
}

func TestICO(t *testing.T) {
	png := solid(16, 16, color.NRGBA{R: 31, G: 111, B: 235, A: 255})
	ico := encodeICO(png)
	out, mime, err := Normalize(ico)
	if err != nil || mime != "image/x-icon" || !bytes.Equal(out, ico) {
		t.Fatalf("ico %s %v %d", mime, err, len(out))
	}
	if _, _, err := Normalize([]byte{0, 0, 2, 0, 1, 0}); err == nil {
		t.Fatal("cursor")
	}
	if _, _, err := Normalize([]byte{0, 0, 1, 0, 0, 0}); err == nil {
		t.Fatal("lege ico")
	}
	bad := make([]byte, 22)
	bad[2] = 1
	bad[4] = 1
	// size and offset out of range
	if _, _, err := Normalize(bad); err == nil {
		t.Fatal("korte ico")
	}
}

func encodeICO(png []byte) []byte {
	// ICO met één PNG-afbeelding van 16×16.
	buf := make([]byte, 6+16+len(png))
	buf[2] = 1
	buf[4] = 1
	buf[6] = 16
	buf[7] = 16
	binaryPutU32(buf[14:], uint32(len(png)))
	binaryPutU32(buf[18:], 22)
	copy(buf[22:], png)
	return buf
}

func binaryPutU32(b []byte, v uint32) {
	b[0] = byte(v)
	b[1] = byte(v >> 8)
	b[2] = byte(v >> 16)
	b[3] = byte(v >> 24)
}
