package wad

import (
	"bytes"
	"encoding/binary"
	"io"
	"os"
	"testing"
)

type lumpDef struct {
	name string
	data []byte
}

func writeTestWAD(t *testing.T, lumps []lumpDef) string {
	t.Helper()
	tmp, err := os.CreateTemp(t.TempDir(), "wad-*.wad")
	if err != nil {
		t.Fatalf("CreateTemp: %v", err)
	}

	hdr := header{Ident: [4]byte{'P', 'W', 'A', 'D'}, NumLumps: int32(len(lumps))}
	if err := binary.Write(tmp, binary.LittleEndian, hdr); err != nil {
		t.Fatalf("write header: %v", err)
	}

	dir := make([]DirEntry, 0, len(lumps))
	for _, l := range lumps {
		pos, err := tmp.Seek(0, io.SeekCurrent)
		if err != nil {
			t.Fatalf("seek: %v", err)
		}
		if len(l.data) > 0 {
			if _, err := tmp.Write(l.data); err != nil {
				t.Fatalf("write lump %s: %v", l.name, err)
			}
		}
		var name [8]byte
		copy(name[:], []byte(l.name))
		dir = append(dir, DirEntry{
			FilePos: int32(pos),
			Size:    int32(len(l.data)),
			Name8:   name,
		})
	}
	dirOffset, err := tmp.Seek(0, io.SeekCurrent)
	if err != nil {
		t.Fatalf("seek dir: %v", err)
	}
	if err := binary.Write(tmp, binary.LittleEndian, dir); err != nil {
		t.Fatalf("write dir: %v", err)
	}

	hdr.DirOffset = int32(dirOffset)
	if _, err := tmp.Seek(0, io.SeekStart); err != nil {
		t.Fatalf("seek hdr: %v", err)
	}
	if err := binary.Write(tmp, binary.LittleEndian, hdr); err != nil {
		t.Fatalf("rewrite header: %v", err)
	}

	if err := tmp.Close(); err != nil {
		t.Fatalf("close temp wad: %v", err)
	}

	return tmp.Name()
}

func TestOpenAndReadLump(t *testing.T) {
	name := writeTestWAD(t, []lumpDef{
		{name: "MAP01", data: nil},
		{name: "DATA", data: []byte{1, 2, 3}},
	})
	w, err := Open(name)
	if err != nil {
		t.Fatalf("Open: %v", err)
	}
	t.Cleanup(func() { _ = w.Close() })

	if len(w.Dir()) != 2 {
		t.Fatalf("Dir entries=%d want 2", len(w.Dir()))
	}

	data, _, err := w.ReadLumpByName("data")
	if err != nil {
		t.Fatalf("ReadLumpByName: %v", err)
	}
	if !bytes.Equal(data, []byte{1, 2, 3}) {
		t.Fatalf("unexpected lump data: %v", data)
	}
}

func TestFindMapAndLoadMapLumps(t *testing.T) {
	verts := make([]byte, 4)
	lines := make([]byte, 14)
	name := writeTestWAD(t, []lumpDef{
		{name: "MAP01", data: nil},
		{name: "VERTEXES", data: verts},
		{name: "LINEDEFS", data: lines},
		{name: "MAP02", data: nil},
	})
	w, err := Open(name)
	if err != nil {
		t.Fatalf("Open: %v", err)
	}
	t.Cleanup(func() { _ = w.Close() })

	start, end, err := w.FindMap("map01")
	if err != nil {
		t.Fatalf("FindMap: %v", err)
	}
	if start != 0 || end != 3 {
		t.Fatalf("unexpected marker bounds start=%d end=%d", start, end)
	}

	lumps, err := w.LoadMapLumps("map01", "VERTEXES", "LINEDEFS")
	if err != nil {
		t.Fatalf("LoadMapLumps: %v", err)
	}
	if len(lumps) != 2 {
		t.Fatalf("expected 2 lumps, got %d", len(lumps))
	}
	if _, ok := lumps["VERTEXES"]; !ok {
		t.Fatalf("missing VERTEXES lump")
	}
}

func TestLoadMapLumpsMissing(t *testing.T) {
	name := writeTestWAD(t, []lumpDef{{name: "MAP01", data: nil}})
	w, err := Open(name)
	if err != nil {
		t.Fatalf("Open: %v", err)
	}
	t.Cleanup(func() { _ = w.Close() })

	if _, err := w.LoadMapLumps("map01", "VERTEXES"); err == nil {
		t.Fatalf("expected error for missing lump")
	}
}