package edgecli

import (
	"errors"
	"os"
	"strconv"
	"testing"

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

var (
	testBanners = []*BannerContext{
		{
			BannerEdgeID: "BID0",
			BannerName:   "Banner0",
			TenantOrg:    "Org0",
			Username:     "User0",
			Endpoint:     "Endpoint0",
			Token:        "Token0",
		},
		{
			BannerEdgeID: "BID1",
			BannerName:   "Banner1",
			TenantOrg:    "Org1",
			Username:     "User1",
			Endpoint:     "Endpoint1",
			Token:        "Token1",
		},
		{
			BannerEdgeID: "BID2",
			BannerName:   "Banner2",
			TenantOrg:    "Org2",
			Username:     "User2",
			Endpoint:     "Endpoint2",
			Token:        "Token2",
		},
		{
			BannerEdgeID: "BID3",
			BannerName:   "Banner3",
			TenantOrg:    "Org3",
			Username:     "User3",
			Endpoint:     "Endpoint3",
			Token:        "Token3",
		},
		{
			BannerEdgeID: "BID4",
			BannerName:   "Banner4",
			TenantOrg:    "Org4",
			Username:     "User4",
			Endpoint:     "Endpoint4",
			Token:        "Token4",
		},
	}

	testClusters = []*ClusterContext{
		{
			ClusterEdgeID: "CID0",
		},
		{
			ClusterEdgeID: "CID1",
		},
		{
			ClusterEdgeID: "CID2",
		},
		{
			ClusterEdgeID: "CID3",
		},
		{
			ClusterEdgeID: "CID4",
		},
	}

	testCfgs = []*Config{
		{
			// empty config
			BannerContexts:  make(map[string]*BannerContext),
			ClusterContexts: make(map[string]*ClusterContext),
		},
		{
			BannerContexts: map[string]*BannerContext{
				"0": testBanners[0],
				"1": testBanners[1],
				"2": testBanners[2],
			},
			ClusterContexts: map[string]*ClusterContext{
				"0": testClusters[0],
				"1": testClusters[1],
			},
		},
		{
			BannerContexts: map[string]*BannerContext{
				"1": testBanners[1],
				"3": testBanners[3],
			},
			ClusterContexts: map[string]*ClusterContext{
				"0": testClusters[0],
				"2": testClusters[2],
				"4": testClusters[4],
			},
		},
		{
			BannerContexts: map[string]*BannerContext{
				"0": testBanners[0],
				"1": testBanners[1],
				"2": testBanners[2],
				"3": testBanners[3],
				"4": testBanners[4],
			},
			ClusterContexts: map[string]*ClusterContext{
				"0": testClusters[0],
				"1": testClusters[1],
				"2": testClusters[2],
				"3": testClusters[3],
				"4": testClusters[4],
			},
		},
	}
)

func Test_File(t *testing.T) {
	dir := t.TempDir()
	defer os.RemoveAll(dir)
	t.Setenv("HOME", dir)
	path := dir + "/.edge"

	t.Run("Creating .edge", func(t *testing.T) {
		// removing test .edge file if one is found
		if _, err := os.Stat(path); !errors.Is(err, os.ErrNotExist) {
			err = os.Remove(path)
			assert.NoError(t, err)
		}

		// ReadConfig() should generate a test .edge file
		_, err := ReadConfig()
		assert.NoError(t, err)
		_, err = os.Stat(path)
		assert.True(t, !errors.Is(err, os.ErrNotExist))

		// removing test .edge file again
		if _, err := os.Stat(path); !errors.Is(err, os.ErrNotExist) {
			err = os.Remove(path)
			assert.NoError(t, err)
		}

		// WriteConfig() should also generate a test .edge file
		err = WriteConfig(&Config{})
		assert.NoError(t, err)
		_, err = os.Stat(path)
		assert.True(t, !errors.Is(err, os.ErrNotExist))
	})

	t.Run("Read and write to .edge", func(t *testing.T) {
		for _, cfg := range testCfgs {
			err := WriteConfig(cfg)
			assert.NoError(t, err)

			readCfg, err := ReadConfig()
			assert.NoError(t, err)

			assert.Equal(t, cfg, readCfg)
		}
	})
}

func Test_Config(t *testing.T) {
	dir := t.TempDir()
	defer os.RemoveAll(dir)
	t.Setenv("HOME", dir)

	t.Run("Add Banner", func(t *testing.T) {
		cfg := Config{}
		for name, banner := range testBanners {
			// good case
			bc, err := cfg.AddBanner(strconv.Itoa(name),
				banner.BannerEdgeID,
				banner.BannerName,
				banner.Username,
				banner.TenantOrg,
				banner.Endpoint,
				banner.Token,
				banner.TokenTime,
			)
			assert.NoError(t, err)
			assert.Equal(t, banner, bc)
			assert.Equal(t, banner, cfg.BannerContexts[strconv.Itoa(name)])

			// adding a banner that already exists
			_, err = cfg.AddBanner(strconv.Itoa(name),
				banner.BannerEdgeID,
				banner.BannerName,
				banner.Username,
				banner.TenantOrg,
				banner.Endpoint,
				banner.Token,
				banner.TokenTime,
			)
			assert.Error(t, err)
		}
		// adding a banner w/o edgeID
		_, err := cfg.AddBanner("no edge ID", "", "", "", "", "", "", "")
		assert.Error(t, err)
	})

	t.Run("Add Cluster", func(t *testing.T) {
		cfg := Config{}
		for name, cluster := range testClusters {
			// good case
			cc, err := cfg.AddCluster(strconv.Itoa(name), cluster.ClusterEdgeID)
			assert.NoError(t, err)
			assert.Equal(t, cluster, cc)
			assert.Equal(t, cluster, cfg.ClusterContexts[strconv.Itoa(name)])

			// adding a cluster that already exists
			_, err = cfg.AddCluster(strconv.Itoa(name), cluster.ClusterEdgeID)
			assert.Error(t, err)
		}
		// adding a cluster w/o edgeID
		_, err := cfg.AddCluster("no edge ID", "")
		assert.Error(t, err)
	})

	t.Run("Set Banner", func(t *testing.T) {
		for _, cfg := range testCfgs {
			for name := range cfg.BannerContexts {
				err := cfg.SetBanner(name)
				assert.NoError(t, err)
			}
			// invalid name
			err := cfg.SetBanner("not a name")
			assert.Error(t, err)
		}
	})

	t.Run("Set Cluster", func(t *testing.T) {
		for _, cfg := range testCfgs {
			for name := range cfg.ClusterContexts {
				err := cfg.SetCluster(name)
				assert.NoError(t, err)
			}
			// invalid name
			err := cfg.SetCluster("not a name")
			assert.Error(t, err)
		}
	})

	t.Run("Delete Banner", func(t *testing.T) {
		for _, cfg := range testCfgs {
			for name := range cfg.BannerContexts {
				err := cfg.DeleteBanner(name)
				assert.NoError(t, err)
				_, ok := cfg.BannerContexts[name]
				assert.False(t, ok)
			}
			// invalid name
			err := cfg.DeleteBanner("not a name")
			assert.Error(t, err)
		}
	})

	t.Run("Delete Cluster", func(t *testing.T) {
		for _, cfg := range testCfgs {
			for name := range cfg.ClusterContexts {
				err := cfg.DeleteCluster(name)
				assert.NoError(t, err)
				_, ok := cfg.ClusterContexts[name]
				assert.False(t, ok)
			}
			// invalid name
			err := cfg.DeleteCluster("not a name")
			assert.Error(t, err)
		}
	})

	t.Run("Update Banner", func(t *testing.T) {
		for _, cfg := range testCfgs {
			for name, bc := range cfg.BannerContexts {
				err := cfg.UpdateBanner(name, "1", "2", "3", "4", "5", "6")
				assert.NoError(t, err)
				testBanner := BannerContext{
					BannerEdgeID: "1",
					BannerName:   "2",
					Username:     "3",
					TenantOrg:    "4",
					Endpoint:     "5",
					Token:        "6",
					TokenTime:    bc.TokenTime,
				}
				assert.Equal(t, testBanner, cfg.BannerContexts[name])
			}
			// invalid name
			err := cfg.UpdateBanner("not a name", "1", "2", "3", "4", "5", "6")
			assert.Error(t, err)
		}
	})

	t.Run("Update Cluster", func(t *testing.T) {
		for _, cfg := range testCfgs {
			for name := range cfg.ClusterContexts {
				err := cfg.UpdateCluster(name, "1")
				assert.NoError(t, err)
				testBanner := ClusterContext{
					ClusterEdgeID: "1",
				}
				assert.Equal(t, testBanner, cfg.ClusterContexts[name])
			}
			// invalid name
			err := cfg.UpdateCluster("not a name", "1")
			assert.Error(t, err)
		}
	})
}