package mapfmt

import (
	"testing"
)

func TestParseVertices(t *testing.T) {
	data := []byte{
		0, 0, 0, 0, // (0,0)
		255, 255, 10, 0, // (-1,10)
	}
	verts, err := ParseVertices(data)
	if err != nil {
		t.Fatalf("ParseVertices error: %v", err)
	}
	if len(verts) != 2 {
		t.Fatalf("got %d vertices", len(verts))
	}
	if verts[1].X != -1 || verts[1].Y != 10 {
		t.Fatalf("unexpected vertex %+v", verts[1])
	}
}

func TestParseVerticesBadSize(t *testing.T) {
	if _, err := ParseVertices([]byte{0}); err == nil {
		t.Fatalf("expected error on odd sized vertex data")
	}
}

func TestParseLinedefs(t *testing.T) {
	data := make([]byte, 14)
	data[0] = 1 // V1
	data[2] = 2 // V2
	lines, err := ParseLinedefs(data)
	if err != nil {
		t.Fatalf("ParseLinedefs error: %v", err)
	}
	if len(lines) != 1 {
		t.Fatalf("expected one linedef")
	}
	if lines[0].V1 != 1 || lines[0].V2 != 2 {
		t.Fatalf("unexpected linedef %+v", lines[0])
	}
}

func TestParseLinedefsBadSize(t *testing.T) {
	if _, err := ParseLinedefs(make([]byte, 13)); err == nil {
		t.Fatalf("expected error on odd sized linedef data")
	}
}

func TestLoadMap(t *testing.T) {
	raw := map[string][]byte{
		"VERTEXES": {0, 0, 0, 0},
		"LINEDEFS": make([]byte, 14),
	}
	m, err := LoadMap(raw)
	if err != nil {
		t.Fatalf("LoadMap error: %v", err)
	}
	if len(m.Vertices) != 1 || len(m.Linedefs) != 1 {
		t.Fatalf("unexpected map data %+v", m)
	}
}

func TestLinedefsToSegs(t *testing.T) {
	verts := []Vertex{{X: 0, Y: 0}, {X: 10, Y: 0}, {X: 10, Y: 0}}
	lines := []Linedef{{V1: 0, V2: 1}, {V1: 1, V2: 2}} // second is degenerate
	segs := LinedefsToSegs(verts, lines)
	if len(segs) != 1 {
		t.Fatalf("expected one segment, got %d", len(segs))
	}
	if segs[0].A.X != 0 || segs[0].B.X != 10 {
		t.Fatalf("unexpected segment: %+v", segs[0])
	}
}