package plotter_test

import (
	"testing"

	"galaxy/game/internal/generator/plotter"
)

func TestNewPlotter(t *testing.T) {
	_, err := plotter.NewPlotter(10, 10, 0)
	if err == nil {
		t.Error("expect: error when factor=0")
	}
	_, err = plotter.NewPlotter(10, 10, -0.01)
	if err == nil {
		t.Error("expect: error when factor<0")
	}
	_, err = plotter.NewPlotter(10, 10, 1.001)
	if err == nil {
		t.Error("expect: error when factor>1")
	}
	_, err = plotter.NewPlotter(10, 10, 1)
	if err != nil {
		t.Error("expect: no error when factor=1")
	}
}

func TestAsPlotterSize(t *testing.T) {
	for _, tc := range []struct {
		w, h   uint32
		f      float64
		ew, eh uint32
	}{
		{10, 10, 0, 10, 10},
		{10, 10, -1, 10, 10},
		{10, 10, 1.1, 10, 10},
		{10, 20, 0.5, 20, 40},
		{30, 60, 0.3, 100, 200},
		{10, 20, 0.25, 40, 80},
	} {
		w, h := plotter.AsPlotterSize(tc.w, tc.h, tc.f)
		if tc.ew != w || tc.eh != h {
			t.Errorf("expect: w=%d h=%d, got: w=%d h=%d", tc.ew, tc.eh, w, h)
		}
	}
}

func TestRandomFreePoint(t *testing.T) {
	var factor float64 = 0.25
	var w, h uint32 = 20, 20
	bm := plotter.NewBitmap(w, h, factor)
	p, err := plotter.NewBitmapPlotter(bm, factor) // 80x80
	if err != nil {
		t.Fatal(err)
	}

	x, y, err := p.RandomFreePoint(3)
	if err != nil {
		t.Errorf("expect: no error getting random point, got: %s", err)
	}
	if x > float64(w) || y > float64(w) {
		t.Errorf("expect: point coordinates within map size %dx%d, got: x=%f y=%f", w, h, x, y)
	}

	_, _, err = p.RandomFreePoint(0)
	if err != nil {
		t.Errorf("expect: no error when radius is zero, got: %s", err)
	}

	_, _, err = p.RandomFreePoint(float64(w + h)) // guaranteed to mark whole area dead zone
	if err != nil {
		t.Errorf("expect: no error getting random point, got: %s", err)
	}

	_, _, err = p.RandomFreePoint(1)
	if err == nil {
		t.Error("expect: error when no free space left, got: none")
	}

	p.Clear()

	_, _, err = p.RandomFreePoint(10)
	if err != nil {
		t.Errorf("expect: no error getting random point after clearing, got: %s", err)
	}
}
