package template_test

import (
	_ "embed"
	"git.wtrh.nl/patterns/gopatterns/pkg/util"
	"math"
	"testing"

	"git.wtrh.nl/patterns/gopatterns/pkg/dimensions"
	"git.wtrh.nl/patterns/gopatterns/pkg/position"
	"git.wtrh.nl/patterns/gopatterns/pkg/position/testutil"
	"git.wtrh.nl/patterns/gopatterns/pkg/template"
	"git.wtrh.nl/patterns/gopatterns/pkg/vector"
	"github.com/stretchr/testify/require"
	"gopkg.in/yaml.v3"
)

//go:embed fixtures/absolute_points.yaml
var absolutePoints []byte

//go:embed fixtures/relative_points.yaml
var relativePoints []byte

//go:embed fixtures/between_points.yaml
var betweenPoints []byte

//go:embed fixtures/extend_points.yaml
var extendPoints []byte

//go:embed fixtures/polar_points.yaml
var polarPoints []byte

//go:embed fixtures/functions.yaml
var functions []byte

//go:embed fixtures/evaluation_functions.yaml
var evaluationFunctions []byte

//go:embed fixtures/references.yaml
var references []byte

func TestAbsolutePoint(t *testing.T) {
	temp := &template.Template{}
	require.NoError(t, yaml.Unmarshal(absolutePoints, temp))

	panel, err := temp.GetPanel(template.Request{
		Dims: dimensions.Dimensions{"test": dimensions.Dimension{
			Name:  "Test",
			Value: 1.3,
		}},
		Panel: "body",
	})
	require.NoError(t, err)

	p1, ok := panel.Points["1"]
	require.True(t, ok)
	require.Equal(t, position.Position{
		Vector: vector.Vector{
			X: 1.3,
			Y: 14.3,
		},
		Rotation: 0,
	}, p1.Position())

	p2, ok := panel.Points["2"]
	require.True(t, ok)
	require.Equal(t, position.Position{
		Vector: vector.Vector{
			X: 2.6,
			Y: -3,
		},
		Rotation: 0,
	}, p2.Position())
}

func TestBetweenPoints(t *testing.T) {
	temp := &template.Template{}
	require.NoError(t, yaml.Unmarshal(betweenPoints, temp))

	panel, err := temp.GetPanel(template.Request{
		Dims: dimensions.Dimensions{"test": dimensions.Dimension{
			Name:  "Test",
			Value: 0.5,
		}},
		Panel: "body",
	})
	require.NoError(t, err)

	p1, ok := panel.Points["1"]
	require.True(t, ok)
	testutil.EqualPosition(t, position.Position{
		Vector: vector.Vector{
			X: 4,
			Y: 14.3,
		},
		Rotation: 0,
	}, p1.Position(), 1e-10)

	p2, ok := panel.Points["2"]
	require.True(t, ok)
	testutil.EqualPosition(t, position.Position{
		Vector: vector.Vector{
			X: 6,
			Y: 11.3,
		},
		Rotation: 0,
	}, p2.Position(), 1e-10)

	p3, ok := panel.Points["3"]
	require.True(t, ok)
	testutil.EqualPosition(t, position.Position{
		Vector: vector.Vector{
			X: 5,
			Y: 12.8,
		},
		Rotation: math.Atan2(-3, 2) - math.Pi/2,
	}, p3.Position(), 1e-10)
}

func TestRelativePoints(t *testing.T) {
	temp := &template.Template{}
	require.NoError(t, yaml.Unmarshal(relativePoints, temp))

	panel, err := temp.GetPanel(template.Request{
		Dims: dimensions.Dimensions{"test": dimensions.Dimension{
			Name:  "Test",
			Value: 1.3,
		}},
		Panel: "body",
	})
	require.NoError(t, err)

	p1, ok := panel.Points["1"]
	require.True(t, ok)
	testutil.EqualPosition(t, position.Position{
		Vector: vector.Vector{
			X: 1.3,
			Y: 14.3,
		},
		Rotation: 0,
	}, p1.Position(), 1e-10)

	p2, ok := panel.Points["2"]
	require.True(t, ok)
	testutil.EqualPosition(t, position.Position{
		Vector: vector.Vector{
			X: 3.9,
			Y: 11.3,
		},
		Rotation: 0,
	}, p2.Position(), 1e-10)
}

func TestExtendPoints(t *testing.T) {
	temp := &template.Template{}
	require.NoError(t, yaml.Unmarshal(extendPoints, temp))

	panel, err := temp.GetPanel(template.Request{
		Dims: dimensions.Dimensions{"test": dimensions.Dimension{
			Name:  "Test",
			Value: 1.3,
		}},
		Panel: "body",
	})
	require.NoError(t, err)

	p1, ok := panel.Points["1"]
	require.True(t, ok)
	testutil.EqualPosition(t, position.Position{}, p1.Position(), 1e-10)

	p2, ok := panel.Points["2"]
	require.True(t, ok)
	testutil.EqualPosition(t, position.Position{
		Vector: vector.Vector{
			X: 4,
			Y: 3,
		},
		Rotation: 0,
	}, p2.Position(), 1e-10)

	p3, ok := panel.Points["3"]
	require.True(t, ok)
	testutil.EqualPosition(t, position.Position{
		Vector: vector.Vector{
			X: 8,
			Y: 6,
		},
		Rotation: math.Atan2(3, 4) - math.Pi/2,
	}, p3.Position(), 1e-10)
}

func TestPolarPoints(t *testing.T) {
	temp := &template.Template{}
	require.NoError(t, yaml.Unmarshal(polarPoints, temp))

	panel, err := temp.GetPanel(template.Request{
		Dims: dimensions.Dimensions{"test": dimensions.Dimension{
			Name:  "Test",
			Value: 1.3,
		}},
		Panel: "body",
	})
	require.NoError(t, err)

	p1, ok := panel.Points["1"]
	require.True(t, ok)
	testutil.EqualPosition(t, position.Position{}, p1.Position(), 1e-10)

	p2, ok := panel.Points["2"]
	require.True(t, ok)
	testutil.EqualPosition(t, position.Position{
		Vector: vector.Vector{
			X: 1,
			Y: 0,
		},
		Rotation: 0,
	}, p2.Position(), 1e-10)

	p3, ok := panel.Points["3"]
	require.True(t, ok)
	testutil.EqualPosition(t, position.Position{
		Vector: vector.Vector{
			X: 1,
			Y: 1,
		},
		Rotation: math.Pi / 2,
	}, p3.Position(), 1e-10)
}

func TestFunctions(t *testing.T) {
	tests := map[string]struct {
		result float64
	}{
		"distance":   {result: 5},
		"angle":      {result: math.Atan2(3, 4)},
		"yDistance":  {result: 3},
		"xDistance":  {result: 4},
		"lineLength": {result: 12},
		"lineLength2": {result: 4},
	}
	temp := &template.Template{}
	require.NoError(t, yaml.Unmarshal(functions, temp))

	panel, err := temp.GetPanel(template.Request{Panel: "test"})
	require.NoError(t, err)

	for name, test := range tests {
		t.Run(name, func(t *testing.T) {
			p, ok := panel.Points[util.ID(name)]
			require.True(t, ok)
			require.InDelta(t, test.result, p.Vector().X, 1e-10)
		})
	}
}

func TestEvaluationFunctions(t *testing.T) {
	tests := map[string]struct {
		result float64
	}{
		"acos":  {result: math.Acos(0.5)},
		"asin":  {result: math.Asin(math.Pi / 2)},
		"atan2": {result: math.Atan2(1, 1)},
		"abs1":  {result: math.Abs(-1.4)},
		"abs2":  {result: math.Abs(3.5)},
	}
	temp := &template.Template{}
	require.NoError(t, yaml.Unmarshal(evaluationFunctions, temp))

	panel, err := temp.GetPanel(template.Request{Panel: "test"})
	require.NoError(t, err)

	for name, test := range tests {
		t.Run(name, func(t *testing.T) {
			p, ok := panel.Points[util.ID(name)]
			require.True(t, ok)
			require.InDelta(t, test.result, p.Vector().X, 1e-10)
		})
	}
}

func TestReferences(t *testing.T) {
	temp := &template.Template{}
	require.NoError(t, yaml.Unmarshal(references, temp))

	panel, err := temp.GetPanel(template.Request{Panel: "body"})
	require.NoError(t, err)

	_ = panel
}