package assets

import (
	"embed"
	"os"
	"path/filepath"
	"testing"
	"testing/fstest"
)

//go:embed testdata
var testFS embed.FS

func TestProvisionCopiesBundledFiles(t *testing.T) {
	dest := t.TempDir()

	if err := Provision(testFS, dest); err != nil {
		t.Fatalf("Provision returned error: %v", err)
	}

	for _, rel := range []string{
		"testdata/fonts/TestFont.ttf",
		"testdata/shaders/solid_color.frag",
		"testdata/shaders/solid_color.vert",
		"testdata/tos/01 - WELCOME.html",
	} {
		got, err := os.ReadFile(filepath.Join(dest, filepath.FromSlash(rel)))
		if err != nil {
			t.Errorf("expected %s to be provisioned: %v", rel, err)
			continue
		}
		want, err := testFS.ReadFile(rel)
		if err != nil {
			t.Fatalf("reading fixture %s: %v", rel, err)
		}
		if string(got) != string(want) {
			t.Errorf("provisioned %s content mismatch", rel)
		}
	}
}

// TestProvisionAssetsStripsEmbeddedRoot is a regression test: provisioning
// used to preserve the embedded share/radiantwave root, so assets landed in
// <dataDir>/share/radiantwave/fonts instead of <dataDir>/fonts. ProvisionAssets
// strips that root so consumers find the assets directly under the assets dir.
func TestProvisionAssetsStripsEmbeddedRoot(t *testing.T) {
	fsys := fstest.MapFS{
		"share/radiantwave/fonts/TestFont.ttf":    &fstest.MapFile{Data: []byte("font")},
		"share/radiantwave/shaders/text.frag":     &fstest.MapFile{Data: []byte("frag")},
		"share/radiantwave/shaders/text.vert":     &fstest.MapFile{Data: []byte("vert")},
		"share/radiantwave/tos/01 - WELCOME.html": &fstest.MapFile{Data: []byte("welcome")},
	}
	dest := t.TempDir()

	if err := ProvisionAssets(fsys, dest); err != nil {
		t.Fatalf("ProvisionAssets returned error: %v", err)
	}

	// Assets must land directly under dest, not under dest/share/radiantwave.
	for _, rel := range []string{
		"fonts/TestFont.ttf",
		"shaders/text.frag",
		"shaders/text.vert",
		"tos/01 - WELCOME.html",
	} {
		if _, err := os.Stat(filepath.Join(dest, filepath.FromSlash(rel))); err != nil {
			t.Errorf("expected %s to be provisioned directly under dest: %v", rel, err)
		}
	}

	if _, err := os.Stat(filepath.Join(dest, "share")); !os.IsNotExist(err) {
		t.Errorf("unexpected share/ directory created under dest: %v", err)
	}
}

func TestProvisionOverwritesStaleFiles(t *testing.T) {
	dest := t.TempDir()

	// Plant a stale shader that differs from the bundled one.
	stalePath := filepath.Join(dest, "testdata", "shaders", "solid_color.vert")
	if err := os.MkdirAll(filepath.Dir(stalePath), 0755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(stalePath, []byte("stale content"), 0644); err != nil {
		t.Fatal(err)
	}

	if err := Provision(testFS, dest); err != nil {
		t.Fatalf("Provision returned error: %v", err)
	}

	got, err := os.ReadFile(stalePath)
	if err != nil {
		t.Fatalf("reading provisioned file: %v", err)
	}
	want, _ := testFS.ReadFile("testdata/shaders/solid_color.vert")
	if string(got) != string(want) {
		t.Errorf("stale file was not overwritten: got %q want %q", got, want)
	}
}