package gocompiler

import (
	"errors"
	"testing"

	"github.com/aperturerobotics/util/enabled"
	bldr_platform "github.com/s4wave/spacewave/bldr/platform"
	bldr_platform_go "github.com/s4wave/spacewave/bldr/platform/go"
)

func TestResolveTinyGoEnabled(t *testing.T) {
	testCases := []struct {
		name           string
		platformID     string
		opt            enabled.Enabled
		defaultEnabled bool
		expected       bool
		expectError    bool
	}{
		{
			name:       "explicit browser go plugin",
			platformID: "web/js/wasm",
			opt:        enabled.Enabled_ENABLE,
			expected:   true,
		},
		{
			name:        "explicit js unsupported",
			platformID:  "js",
			opt:         enabled.Enabled_ENABLE,
			expectError: true,
		},
		{
			name:        "explicit native unsupported",
			platformID:  "desktop/linux/amd64",
			opt:         enabled.Enabled_ENABLE,
			expectError: true,
		},
		{
			name:       "default preserves standard go",
			platformID: "web/js/wasm",
			opt:        enabled.Enabled_DEFAULT,
			expected:   false,
		},
		{
			name:           "default stays disabled for browser",
			platformID:     "web/js/wasm",
			opt:            enabled.Enabled_DEFAULT,
			defaultEnabled: true,
			expected:       false,
		},
		{
			name:           "disable overrides default",
			platformID:     "web/js/wasm",
			opt:            enabled.Enabled_DISABLE,
			defaultEnabled: true,
			expected:       false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Parse the platform for this TinyGo enablement case.
			plat, err := bldr_platform.ParsePlatform(tc.platformID)
			if err != nil {
				t.Fatalf("%s: unexpected error: %s", tc.platformID, err.Error())
			}

			// Resolve TinyGo enablement for the configured platform and policy.
			actual, err := ResolveTinyGoEnabled(plat, tc.opt, tc.defaultEnabled)

			// Verify TinyGo enablement or the unsupported platform error.
			if tc.expectError {
				if err == nil {
					t.Fatalf("%s: expected error but got none", tc.platformID)
				}
				if !errors.Is(err, bldr_platform_go.ErrTinyGoUnsupported) {
					t.Fatalf("%s: expected ErrTinyGoUnsupported, got %s", tc.platformID, err.Error())
				}
				return
			}
			if err != nil {
				t.Fatalf("%s: unexpected error: %s", tc.platformID, err.Error())
			}
			if actual != tc.expected {
				t.Fatalf("%s: expected %v got %v", tc.platformID, tc.expected, actual)
			}
		})
	}
}

func TestDefaultTinyGoEnabled(t *testing.T) {
	testCases := []struct {
		name       string
		platformID string
		isRelease  bool
		expected   bool
	}{
		{
			name:       "release browser wasm",
			platformID: "web/js/wasm",
			isRelease:  true,
			expected:   true,
		},
		{
			name:       "dev browser wasm",
			platformID: "web/js/wasm",
		},
		{
			name:       "release js fallback",
			platformID: "js",
			isRelease:  true,
		},
		{
			name:       "release native",
			platformID: "desktop/linux/amd64",
			isRelease:  true,
		},
		{
			name:       "release wasi",
			platformID: "web/wasi/wasm",
			isRelease:  true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			plat, err := bldr_platform.ParsePlatform(tc.platformID)
			if err != nil {
				t.Fatalf("%s: unexpected error: %s", tc.platformID, err.Error())
			}
			if got := DefaultTinyGoEnabled(plat, tc.isRelease); got != tc.expected {
				t.Fatalf("%s: default TinyGo = %v, want %v", tc.platformID, got, tc.expected)
			}
		})
	}
}