package emulator

import (
	"context"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"testing"

	"github.com/stretchr/testify/assert"

	"edge-infra.dev/pkg/lib/fog"
)

func EqualError(msg string) assert.ErrorAssertionFunc {
	return func(t assert.TestingT, err error, _ ...interface{}) bool {
		return assert.EqualError(t, err, msg)
	}
}

func TestGetRootDir(t *testing.T) {
	cases := map[string]struct {
		dir       string
		exp       string
		errAssert assert.ErrorAssertionFunc
	}{
		"Valid": {
			dir:       os.TempDir(),
			exp:       os.TempDir(),
			errAssert: assert.NoError,
		},
		"Invalid Path": {
			dir:       "not/a/val id/path",
			exp:       "",
			errAssert: EqualError("workspace directory could not be found: stat not/a/val id/path: no such file or directory"),
		},
		"No Path": {
			dir:       "",
			exp:       defaultDir,
			errAssert: assert.NoError,
		},
	}
	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			t.Setenv(envFilePathDir, tc.dir)
			dir, err := GetWorkspaceDir(fog.New())
			tc.errAssert(t, err)
			assert.Equal(t, tc.exp, dir)
		})
	}
}

func TestGetRootDirWithPerms(t *testing.T) {
	cases := map[string]struct {
		dir       string
		mode      fs.FileMode
		errAssert assert.ErrorAssertionFunc
	}{
		"RWX": {
			dir:       t.TempDir(),
			mode:      0744,
			errAssert: assert.NoError,
		},
		"Read Write": {
			dir:       t.TempDir(),
			mode:      0644,
			errAssert: EqualError("workspace directory perms aren't accessible by remotecli"),
		},
		"Read": {
			dir:       t.TempDir(),
			mode:      0444,
			errAssert: EqualError("workspace directory perms aren't accessible by remotecli"),
		},
		"No Access": {
			dir:       t.TempDir(),
			mode:      0000,
			errAssert: EqualError("workspace directory perms aren't accessible by remotecli"),
		},
	}
	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			err := os.Chmod(tc.dir, tc.mode)
			assert.NoError(t, err)
			t.Setenv(envFilePathDir, tc.dir)

			_, err = GetWorkspaceDir(fog.New())
			tc.errAssert(t, err)
		})
	}
}

func TestNewWorkspace(t *testing.T) {
	projectID, bannerID, storeID := "project", "banner", "store"
	data := []byte(fmt.Sprintf(`
{
	"project_ID": "%s",
	"banner_ID": "%s",
	"store_ID": "%s"
}`, projectID, bannerID, storeID))

	filepath := createTempFile(t)
	err := os.WriteFile(filepath, data, 0644)
	assert.NoError(t, err)

	expected := &workspace{
		ProjectID: projectID,
		BannerID:  bannerID,
		StoreID:   storeID,
	}
	ws, err := newWorkspace(filepath)
	assert.NoError(t, err)
	assert.Equal(t, expected, ws)
}

func TestNewWorkspaceBadEnv(t *testing.T) {
	expected := &workspace{}
	ws, err := newWorkspace("a/bad/file/path")
	assert.Error(t, err)
	assert.Equal(t, expected, ws)
}

func TestLoadFiles(t *testing.T) {
	projectID, bannerID, storeID := "project", "banner", "store"
	ctx := context.Background()
	dir := t.TempDir()
	config := NewConfig(ctx, dir)
	em := NewEmulator(ctx, &cliService{}, config)

	makeTempFile := func(name, data string) (f *os.File) {
		f, err := os.Create(filepath.Join(dir, name))
		assert.NoError(t, err)
		_, err = f.WriteString(data)
		assert.NoError(t, err)
		return f
	}

	data := "connect a b c d"
	connectHistoryFile := makeTempFile(connectHistoryFileName, data)
	defer connectHistoryFile.Close()
	expectedConnectHistory := []string{data}

	data = "echo hello"
	sessionHistoryFile := makeTempFile(sessionHistoryFileName, data)
	defer sessionHistoryFile.Close()
	expectedSessionHistory := []string{data}

	data = fmt.Sprintf(`
{
	"project_ID": "%s",
	"banner_ID": "%s",
	"store_ID": "%s"
}`, projectID, bannerID, storeID)
	workspaceFile := makeTempFile(workspaceFileName, data)
	defer workspaceFile.Close()
	expectedWorkspace := &workspace{
		ProjectID: projectID,
		BannerID:  bannerID,
		StoreID:   storeID,
	}

	em.loadWorkspace(connectHistoryFile.Name(), sessionHistoryFile.Name(), workspaceFile.Name())

	assert.Equal(t, expectedSessionHistory, em.sessionHistory.history)
	assert.Equal(t, expectedConnectHistory, em.connectHistory.history)
	assert.Equal(t, expectedWorkspace, em.workspace)
}