package tins2020

import (
	"math/rand"

	"opslag.de/schobers/geom/noise"
)

type Game struct {
	Terrain *Map
	Flowers []Flower
	Bees    []Bee
}

type Map struct {
	Temp    NoiseMap
	Humid   NoiseMap
	Variant NoiseMap
	PlaceX  NoiseMap // displacement map of props
	PlaceY  NoiseMap
}

type NoiseMap interface {
	Value(x, y int32) float64
}

func NewNoiseMap(seed int64) NoiseMap {
	return &noiseMap{
		noise:     noise.NewPerlin(seed),
		alpha:     2,
		beta:      4,
		harmonics: 2,
	}
}

func NewRandomNoiseMap(seed int64) NoiseMap {
	return &randomNoiseMap{noise.NewPerlin(seed)}
}

type noiseMap struct {
	noise       *noise.Perlin
	alpha, beta float64
	harmonics   int
}

func clipNormalized(x float64) float64 {
	if x < 0 {
		return 0
	}
	if x > 1 {
		return 1
	}
	return x
}

// Value generates the noise value for an x/y pair. The range of the output is approximately [-1.325825214,1.325825214] (for 4 harmonics).
func (m *noiseMap) Value(x, y int32) float64 {
	value := m.noise.Noise2D(float64(x)*.01, float64(y)*.01, m.alpha, m.beta, m.harmonics)*.565 + .5
	return clipNormalized(value)
}

type randomNoiseMap struct {
	*noise.Perlin
}

// Value generates the noise value for an x/y pair. The range of the output is approximately [-1.325825214,1.325825214] (for 4 harmonics).
func (m randomNoiseMap) Value(x, y int32) float64 {
	value := m.Noise2D(float64(x)*.53, float64(y)*.53, 1.01, 2, 2)*.5 + .5
	return clipNormalized(value)
}

func NewGame() *Game {
	terrain := &Map{
		Temp:    NewNoiseMap(rand.Int63()),
		Humid:   NewNoiseMap(rand.Int63()),
		Variant: NewRandomNoiseMap(rand.Int63()),
		PlaceX:  NewRandomNoiseMap(rand.Int63()),
		PlaceY:  NewRandomNoiseMap(rand.Int63()),
	}
	return &Game{
		Terrain: terrain,
		Flowers: []Flower{},
		Bees:    []Bee{},
	}
}

type Flower struct {
	Location PointF
}

type Bee struct {
	Location PointF
}