package windows

import (
	"errors"
	"path/filepath"
	"testing"
)

func TestPlatformStubContract(t *testing.T) {
	platform := New()
	if platform.OS() == "" {
		t.Fatal("OS() should not be empty")
	}
	if platform.Edition() != EditionModern {
		t.Fatalf("Edition() = %q, want %q", platform.Edition(), EditionModern)
	}
}

func TestEntrypointIsRunningUsesFullPathIdentity(t *testing.T) {
	root := t.TempDir()
	target := filepath.Join(root, "one", "App.exe")
	collision := filepath.Join(root, "two", "App.exe")

	running, err := entrypointIsRunning(target, func() (processSnapshot, error) {
		return &scriptedSnapshot{items: []snapshotItem{{path: collision}}}, nil
	})
	if err != nil {
		t.Fatalf("entrypointIsRunning() error = %v", err)
	}
	if running {
		t.Fatal("entrypointIsRunning() matched a same-basename executable in another directory")
	}

	running, err = entrypointIsRunning(target, func() (processSnapshot, error) {
		return &scriptedSnapshot{items: []snapshotItem{{path: collision}, {path: target}}}, nil
	})
	if err != nil || !running {
		t.Fatalf("entrypointIsRunning() = (%v, %v), want (true, nil)", running, err)
	}
}

func TestEntrypointIsRunningFailsClosedForSnapshotErrors(t *testing.T) {
	expected := errors.New("snapshot failed")
	_, err := entrypointIsRunning("App.exe", func() (processSnapshot, error) {
		return nil, expected
	})
	if !errors.Is(err, expected) {
		t.Fatalf("entrypointIsRunning() error = %v, want %v", err, expected)
	}

	_, err = entrypointIsRunning("App.exe", func() (processSnapshot, error) {
		return &scriptedSnapshot{items: []snapshotItem{{err: expected}}}, nil
	})
	if !errors.Is(err, expected) {
		t.Fatalf("entrypointIsRunning() error = %v, want %v", err, expected)
	}
}

func TestVersionSupports(t *testing.T) {
	cases := []struct {
		minOS                        string
		major, minor, build, service uint32
		want                         bool
		wantErr                      bool
	}{
		{minOS: "windows-7-sp1", major: 6, minor: 1, service: 1, want: true},
		{minOS: "windows-7-sp1", major: 6, minor: 1, service: 0, want: false},
		{minOS: "windows-10", major: 10, want: true},
		{minOS: "windows-11", major: 10, build: 19045, want: false},
		{minOS: "windows-11", major: 10, build: 22000, want: true},
		{minOS: "unknown", wantErr: true},
	}
	for _, test := range cases {
		got, err := versionSupports(test.minOS, test.major, test.minor, test.build, test.service)
		if (err != nil) != test.wantErr || got != test.want {
			t.Fatalf("versionSupports(%q, %d, %d, %d, %d) = (%v, %v), want (%v, error=%v)", test.minOS, test.major, test.minor, test.build, test.service, got, err, test.want, test.wantErr)
		}
	}
}

type snapshotItem struct {
	path string
	err  error
}

type scriptedSnapshot struct {
	items []snapshotItem
	next  int
}

func (snapshot *scriptedSnapshot) NextImagePath() (string, bool, error) {
	if snapshot.next == len(snapshot.items) {
		return "", false, nil
	}
	item := snapshot.items[snapshot.next]
	snapshot.next++
	return item.path, true, item.err
}

func (*scriptedSnapshot) Close() error { return nil }