package authservice

import (
	"flag"
	"testing"

	"github.com/peterbourgon/ff/v3"
	"github.com/stretchr/testify/assert"
)

func TestBindConfigFlagsUserService(t *testing.T) {
	EnvUserServiceHost := "EA_USER_SERVICE_HOST"

	tests := map[string]struct {
		val      string
		expected string
	}{
		"Set UserService Env": {
			val:      "test",
			expected: "test",
		},
		"Unset UserServiceEnv Env": {
			val:      "",
			expected: defaultUserServiceHost,
		},
	}

	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			t.Setenv(EnvUserServiceHost, tc.val)
			config := Config{}
			flags := flag.NewFlagSet("test", flag.ExitOnError)
			config.BindFlags(flags)
			err := ff.Parse(flags, []string{}, ff.WithEnvVarNoPrefix(), ff.WithIgnoreUndefined(true))
			assert.NoError(t, err)
			assert.Equal(t, config.UserServiceHost, tc.expected)
		})
	}
}

func TestBindConfigFlagsRulesEngine(t *testing.T) {
	EnvRulesEngineHost := "EA_RULES_ENGINE_HOST"
	tests := map[string]struct {
		val      string
		expected string
	}{
		"Set RulesEngine Env": {
			val:      "test",
			expected: "test",
		},
		"Unset RulesEngine Env": {
			val:      "",
			expected: defaultRulesEngineHost,
		},
	}

	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			t.Setenv(EnvRulesEngineHost, tc.val)
			config := Config{}
			flags := flag.NewFlagSet("test", flag.ExitOnError)
			config.BindFlags(flags)
			err := ff.Parse(flags, []string{}, ff.WithEnvVarNoPrefix(), ff.WithIgnoreUndefined(true))
			assert.NoError(t, err)
			assert.Equal(t, tc.expected, config.RulesEngineHost)
		})
	}
}

func TestBindConfigFlagsEdgeAPI(t *testing.T) {
	tests := map[string]struct {
		flags           []string
		expEdgeAPI      string
		validationError assert.ErrorAssertionFunc
	}{
		"Set Edge API Value": {
			flags:           []string{`--edge-api`, `https://dev1.edge-preprod.dev/api/v2`},
			expEdgeAPI:      "https://dev1.edge-preprod.dev/api/v2",
			validationError: assert.NoError,
		},
		"Unset Edge API Value": {
			flags:           []string{`--edge-api`, ``},
			expEdgeAPI:      "",
			validationError: EqualError("edge api url required"),
		},
	}

	for name, tc := range tests {
		tc := tc
		t.Run(name, func(t *testing.T) {
			t.Parallel()

			conf := Config{}
			flags := flag.NewFlagSet("test", flag.ExitOnError)
			conf.BindFlags(flags)
			err := ff.Parse(flags, tc.flags, ff.WithEnvVarNoPrefix(), ff.WithIgnoreUndefined(true))
			assert.NoError(t, err)

			assert.Equal(t, tc.expEdgeAPI, conf.EdgeAPI)

			err = conf.Validate()
			tc.validationError(t, err)
		})
	}
}