package cli

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"testing"

	"github.com/crossplane/crossplane-runtime/pkg/test"
	"github.com/google/go-cmp/cmp"
	"github.com/stretchr/testify/assert"

	"github.com/oam-dev/kubevela/apis/types"
	"github.com/oam-dev/kubevela/references/plugins"
)

const BaseDir = "testdata"

var TestDir = filepath.Join(BaseDir, "show")

func TestCreateTestDir(t *testing.T) {
	if _, err := os.Stat(TestDir); err != nil && os.IsNotExist(err) {
		err := os.MkdirAll(TestDir, 0750)
		assert.NoError(t, err)
	}
}

func TestGenerateSideBar(t *testing.T) {
	workloadName := "workload1"
	traitName := "trait1"

	cases := map[string]struct {
		reason       string
		capabilities []types.Capability
		want         error
	}{
		"WorkloadTypeAndTraitCapability": {
			reason: "valid capabilities",
			capabilities: []types.Capability{
				{
					Name: workloadName,
					Type: types.TypeWorkload,
				},
				{
					Name: traitName,
					Type: types.TypeTrait,
				},
			},
			want: nil,
		},
	}

	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			got := generateSideBar(tc.capabilities, TestDir)
			if diff := cmp.Diff(tc.want, got, test.EquateErrors()); diff != "" {
				t.Errorf("\n%s\ngenerateSideBar(...): -want error, +got error:\n%s", tc.reason, diff)
			}
			data, err := ioutil.ReadFile(filepath.Clean(filepath.Join(TestDir, SideBar)))
			assert.NoError(t, err)
			for _, c := range tc.capabilities {
				assert.Contains(t, string(data), c.Name)
			}
		})
	}
}

func TestGenerateNavBar(t *testing.T) {
	assert.NoError(t, generateNavBar(TestDir))
	_, err := os.Stat(filepath.Clean(filepath.Join(TestDir, NavBar)))
	assert.NoError(t, err)
}

func TestGenerateIndexHTML(t *testing.T) {
	assert.NoError(t, generateIndexHTML(TestDir))
	_, err := os.Stat(filepath.Clean(filepath.Join(TestDir, IndexHTML)))
	assert.NoError(t, err)
}

func TestGenerateCustomCSS(t *testing.T) {
	assert.NoError(t, generateCustomCSS(TestDir))
	_, err := os.Stat(filepath.Clean(filepath.Join(TestDir, CSS)))
	assert.NoError(t, err)
}

func TestGenerateREADME(t *testing.T) {
	workloadName := "workload1"
	traitName := "trait1"

	cases := map[string]struct {
		reason       string
		capabilities []types.Capability
		want         error
	}{
		"WorkloadTypeAndTraitCapability": {
			reason: "valid capabilities",
			capabilities: []types.Capability{
				{
					Name: workloadName,
					Type: types.TypeWorkload,
				},
				{
					Name: traitName,
					Type: types.TypeTrait,
				},
			},
			want: nil,
		},
	}
	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			got := generateREADME(tc.capabilities, TestDir)
			if diff := cmp.Diff(tc.want, got, test.EquateErrors()); diff != "" {
				t.Errorf("\n%s\ngenerateREADME(...): -want error, +got error:\n%s", tc.reason, diff)
			}
			data, err := ioutil.ReadFile(filepath.Clean(filepath.Join(TestDir, README)))
			assert.NoError(t, err)
			for _, c := range tc.capabilities {
				switch c.Type {
				case types.TypeWorkload:
					assert.Contains(t, string(data), fmt.Sprintf("  - [%s](%s/%s.md)\n", c.Name, plugins.WorkloadTypePath, c.Name))
				case types.TypeTrait:
					assert.Contains(t, string(data), fmt.Sprintf("  - [%s](%s/%s.md)\n", c.Name, plugins.TraitPath, c.Name))
				}
			}
		})
	}
}

func TestGetWorkloadAndTraits(t *testing.T) {
	type want struct {
		workloads []string
		traits    []string
	}
	workloadName := "workload1"
	traitName := "trait1"
	scopeName := "scope1"

	cases := map[string]struct {
		reason       string
		capabilities []types.Capability
		want         want
	}{
		"WorkloadTypeAndTraitCapability": {
			reason: "valid capabilities",
			capabilities: []types.Capability{
				{
					Name: workloadName,
					Type: types.TypeWorkload,
				},
				{
					Name: traitName,
					Type: types.TypeTrait,
				},
			},
			want: want{
				workloads: []string{workloadName},
				traits:    []string{traitName},
			},
		},
		"ScopeTypeCapability": {
			reason: "invalid capabilities",
			capabilities: []types.Capability{
				{
					Name: scopeName,
					Type: types.TypeScope,
				},
			},
			want: want{
				workloads: nil,
				traits:    nil,
			},
		},
	}
	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			gotWorkloads, gotTraits := getWorkloadsAndTraits(tc.capabilities)
			assert.Equal(t, tc.want, want{workloads: gotWorkloads, traits: gotTraits})
		})
	}
}

func TestDeleteTestDir(t *testing.T) {
	if _, err := os.Stat(BaseDir); err == nil {
		err := os.RemoveAll(BaseDir)
		assert.NoError(t, err)
	}
}