package emulatorsvc

import (
	"os"
	"path/filepath"
	"testing"

	"github.com/stretchr/testify/assert"
)

// authFile tests

func TestOpenAuthFile(t *testing.T) {
	t.Parallel()
	dir := t.TempDir()
	emptyDir := t.TempDir()

	cases := map[string]struct {
		dir       string
		data      []byte
		expected  *AuthFile
		errAssert assert.ErrorAssertionFunc
	}{
		"Valid": {
			dir: dir,
			data: []byte(`
defaultProfile: default
profiles:
  default:
    username: a
    organization: b
    apiEndpoint: c
  second:
    username: d
    organization: e
    apiEndpoint: f
  third:
    username: g
    organization: h
    apiEndpoint: i
`),
			expected: &AuthFile{
				path:           filepath.Join(dir, authFileName),
				DefaultProfile: "default",
				Profiles: map[string]Profile{
					"default": {
						Username:     "a",
						Organization: "b",
						API:          "c",
					},
					"second": {
						Username:     "d",
						Organization: "e",
						API:          "f",
					},
					"third": {
						Username:     "g",
						Organization: "h",
						API:          "i",
					},
				},
			},
			errAssert: assert.NoError,
		},
		"Invalid File": {
			dir: emptyDir,
			data: []byte(`
defau
`),
			expected:  nil,
			errAssert: assert.Error,
		},
		"Duplicate Profile Names": {
			dir: dir,
			data: []byte(`
defaultProfile: default
profiles:
  default:
    username: a
    organization: b
    apiEndpoint: c
  second:
    username: d
    organization: e
    apiEndpoint: f
  second:
    username: g
    organization: h
    apiEndpoint: i
`),
			expected:  nil,
			errAssert: assert.Error,
		},
	}

	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			path := filepath.Join(tc.dir, authFileName)
			err := os.WriteFile(path, tc.data, 0640)
			assert.NoError(t, err)

			af, err := OpenAuthFile(tc.dir)
			tc.errAssert(t, err)
			assert.Equal(t, tc.expected, af)
		})
	}
}

func TestOpenAuthFileFileDoesNotExist(t *testing.T) {
	dir := t.TempDir()
	expected := &AuthFile{
		path:           filepath.Join(dir, authFileName),
		DefaultProfile: "",
		Profiles:       make(map[string]Profile),
	}
	actual, err := OpenAuthFile(dir)
	assert.NoError(t, err)
	assert.Equal(t, expected, actual)
}

func TestUpdateAuthFile(t *testing.T) {
	t.Parallel()

	cases := map[string]struct {
		data      []byte
		profile   Profile
		name      string
		expected  string
		errAssert assert.ErrorAssertionFunc
	}{
		"Empty File No Name": {
			data: nil,
			profile: Profile{
				Username:     "a",
				Password:     "password",
				Organization: "b",
				API:          "c",
			},
			expected: `
defaultProfile: default
profiles:
  default:
    username: a
    organization: b
    apiEndpoint: c
`,
			errAssert: assert.NoError,
		},
		"Empty File Name Given": {
			data: nil,
			profile: Profile{
				Username:     "a",
				Password:     "password",
				Organization: "b",
				API:          "c",
			},
			name: "myProfile",
			expected: `
defaultProfile: myProfile
profiles:
  myProfile:
    username: a
    organization: b
    apiEndpoint: c
`,
			errAssert: assert.NoError,
		},
		"No Default Profile": {
			data: []byte(`
profiles:
  profilename:
    username: a
    organization: b
    apiEndpoint: c
`),
			profile: Profile{
				Username:     "a",
				Password:     "password",
				Organization: "b",
				API:          "c",
			},
			expected: `
defaultProfile: default
profiles:
  profilename:
    username: a
    organization: b
    apiEndpoint: c
`,
			errAssert: assert.NoError,
		},
		"No Profiles": {
			data: []byte(`
defaultProfile: profilename
`),
			profile: Profile{
				Username:     "a",
				Password:     "password",
				Organization: "b",
				API:          "c",
			},
			expected: `
defaultProfile: profilename
profiles:
  profilename:
    username: a
    organization: b
    apiEndpoint: c
`,
			errAssert: assert.NoError,
		},
		"No Change With Identical Profile": {
			data: []byte(`
defaultProfile: default
profiles:
  default:
    username: a
    organization: b
    apiEndpoint: c
  second:
    username: d
    organization: e
    apiEndpoint: f
`),
			profile: Profile{
				Username:     "d",
				Password:     "password",
				Organization: "e",
				API:          "f",
			},
			expected: `
defaultProfile: default
profiles:
  default:
    username: a
    organization: b
    apiEndpoint: c
  second:
    username: d
    organization: e
    apiEndpoint: f
`,
			errAssert: assert.NoError,
		},
		"No Change With Different Profile": {
			data: []byte(`
defaultProfile: default
profiles:
  default:
    username: a
    organization: b
    apiEndpoint: c
  second:
    username: d
    organization: e
    apiEndpoint: f
`),
			profile: Profile{
				Username:     "somethingelse",
				Password:     "password",
				Organization: "somethingelse",
				API:          "somethingelse",
			},
			expected: `
defaultProfile: default
profiles:
  default:
    username: a
    organization: b
    apiEndpoint: c
  second:
    username: d
    organization: e
    apiEndpoint: f
`,
			errAssert: assert.NoError,
		},
	}

	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			dir := t.TempDir()
			path := filepath.Join(dir, authFileName)
			err := os.WriteFile(path, tc.data, 0640)
			assert.NoError(t, err)

			af, err := OpenAuthFile(dir)
			assert.NoError(t, err)

			err = af.UpdateAuthFile(tc.profile, tc.name)
			tc.errAssert(t, err)

			actual, err := os.ReadFile(path)
			assert.NoError(t, err)
			assert.YAMLEq(t, tc.expected, string(actual))
		})
	}
}

func TestWriteFile(t *testing.T) {
	t.Parallel()

	dir := t.TempDir()
	path := filepath.Join(dir, authFileName)
	af := AuthFile{
		path:           path,
		DefaultProfile: "default",
		Profiles: map[string]Profile{
			"default": {
				Username:     "a",
				Organization: "b",
				API:          "c",
			},
		},
	}
	err := af.writeFile()
	assert.NoError(t, err)

	expected := `
defaultProfile: default
profiles:
  default:
    username: a
    organization: b
    apiEndpoint: c
`
	data, err := os.ReadFile(path)
	assert.NoError(t, err)
	assert.YAMLEq(t, expected, string(data))
}

func TestLoadProfile(t *testing.T) {
	t.Parallel()

	af := AuthFile{
		DefaultProfile: "default",
		Profiles: map[string]Profile{
			"default": {
				Username:     "a",
				Organization: "b",
				API:          "c",
			},
		},
	}

	cases := map[string]struct {
		af        AuthFile
		profile   Profile
		name      string
		expected  Profile
		errAssert assert.ErrorAssertionFunc
	}{
		"Empty Profile": {
			af:      af,
			profile: Profile{},
			name:    "default",
			expected: Profile{
				Username:     "a",
				Organization: "b",
				API:          "c",
			},
			errAssert: assert.NoError,
		},
		"Filled Profile Same Values": {
			af: af,
			profile: Profile{
				Username:     "a",
				Organization: "b",
				API:          "c",
			},
			name: "default",
			expected: Profile{
				Username:     "a",
				Organization: "b",
				API:          "c",
			},
			errAssert: assert.NoError,
		},
		"Filled Profile Different Values": {
			af: af,
			profile: Profile{
				Username: "somethingelse",
				API:      "somethingelse",
			},
			name: "default",
			expected: Profile{
				Username:     "somethingelse",
				Organization: "b",
				API:          "somethingelse",
			},
			errAssert: assert.NoError,
		},
		"Name Not In Profiles": {
			af: af,
			profile: Profile{
				Username:     "a",
				Organization: "b",
				API:          "c",
			},
			name:      "somethingelse",
			expected:  Profile{},
			errAssert: assert.Error,
		},
		"Unitialized Auth File": {
			af: AuthFile{},
			profile: Profile{
				Username:     "a",
				Organization: "b",
				API:          "c",
			},
			name: "default",
			expected: Profile{
				Username:     "a",
				Organization: "b",
				API:          "c",
			},
			errAssert: assert.NoError,
		},
		"Empty Name": {
			af: af,
			profile: Profile{
				Username:     "a",
				Organization: "b",
				API:          "c",
			},
			expected: Profile{
				Username:     "a",
				Organization: "b",
				API:          "c",
			},
			errAssert: assert.NoError,
		},
	}

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

			actual, err := tc.af.LoadProfile(tc.profile, tc.name)
			tc.errAssert(t, err)
			assert.Equal(t, tc.expected, actual)
		})
	}
}

// Config tests

func TestNewConfig(t *testing.T) {
	dir := t.TempDir()
	profile := Profile{"a", "b", "c", "d", ""}

	expected := Config{dir, profile}
	actual := NewConfig(dir, profile)
	assert.Equal(t, expected, actual)
}

// Profile tests

func TestRequestEmptyFieldsValid(t *testing.T) {
	t.Parallel()

	profile := Profile{
		Username:     "a",
		Password:     "b",
		API:          "c",
		Organization: "d",
	}
	assert.NoError(t, profile.RequestEmptyFields())
}