package tests

import (
	"io/ioutil"
	"testing"

	"github.com/openwhisk/openwhisk-wskdeploy/parsers"
	"github.com/stretchr/testify/assert"
)

var manifest_yaml = "../../usecases/helloworld/manifest.yaml"
var manifestfile1 = "../../dat/manifest1.yaml"
var manifestfile3 = "../../dat/manifest3.yaml"
var manifestfile4 = "../../dat/manifest4.yaml"
var manifestfile5 = "../../dat/manifest5.yaml"
var manifestfile6 = "../../dat/manifest6.yaml"
var testfile1 = "../../dat/deploy1.yaml"
var testfile2 = "../../dat/deploy2.yaml"
var testfile3 = "../../dat/deploy3.yaml"
var testfile4 = "../../dat/deploy4.yaml"

func TestParseManifestYAML(t *testing.T) {
	data, err := ioutil.ReadFile(manifest_yaml)
	if err != nil {
		panic(err)
	}

	var manifest parsers.ManifestYAML
	err = parsers.NewYAMLParser().Unmarshal(data, &manifest)
	if err != nil {
		panic(err)
	}
	//get and verify package name
	assert.Equal(t, "helloworld", manifest.Package.Packagename, "Get package name failed.")

	count := 0
	for action_name := range manifest.Package.Actions {
		var action = manifest.Package.Actions[action_name]
		//get and verify action location
		//assert.Equal(t, "src/greeting.js", action.Location, "Get action location failed.")
		//get and verify total param number
		assert.Equal(t, 2, len(action.Inputs), "Get input param number failed.")
		count++
	}
	//get and verify action count
	assert.Equal(t, 2, count, "Get action number failed.")

}

func TestParseManifestYAML_trigger(t *testing.T) {
	data, err := ioutil.ReadFile(manifestfile3)
	if err != nil {
		panic(err)
	}

	var manifest parsers.ManifestYAML
	err = parsers.NewYAMLParser().Unmarshal(data, &manifest)
	if err != nil {
		panic(err)
	}

	assert.Equal(t, 2, len(manifest.Package.Triggers), "Get trigger list failed.")
	for trigger_name := range manifest.Package.Triggers {
		var trigger = manifest.Package.Triggers[trigger_name]
		switch trigger_name {
		case "trigger1":
		case "trigger2":
			assert.Equal(t, "myfeed", trigger.Feed, "Get trigger feed name failed.")
		default:
			t.Error("Get trigger name failed")
		}
	}
}

func TestParseManifestYAML_rule(t *testing.T) {
	data, err := ioutil.ReadFile(manifestfile4)
	if err != nil {
		panic(err)
	}

	var manifest parsers.ManifestYAML
	err = parsers.NewYAMLParser().Unmarshal(data, &manifest)
	if err != nil {
		panic(err)
	}

	assert.Equal(t, 1, len(manifest.Package.Rules), "Get trigger list failed.")
	for rule_name := range manifest.Package.Rules {
		var rule = manifest.Package.Rules[rule_name]
		switch rule_name {
		case "rule1":
			assert.Equal(t, "trigger1", rule.Trigger, "Get trigger name failed.")
			assert.Equal(t, "hellpworld", rule.Action, "Get action name failed.")
			assert.Equal(t, "true", rule.Rule, "Get rule expression failed.")
		default:
			t.Error("Get rule name failed")
		}
	}
}

func TestParseManifestYAML_feed(t *testing.T) {
	data, err := ioutil.ReadFile(manifestfile5)
	if err != nil {
		panic(err)
	}

	var manifest parsers.ManifestYAML
	err = parsers.NewYAMLParser().Unmarshal(data, &manifest)
	if err != nil {
		panic(err)
	}

	assert.Equal(t, 1, len(manifest.Package.Feeds), "Get feed list failed.")
	for feed_name := range manifest.Package.Feeds {
		var feed = manifest.Package.Feeds[feed_name]
		switch feed_name {
		case "feed1":
			assert.Equal(t, "https://my.company.com/services/eventHub", feed.Location, "Get feed location failed.")
			assert.Equal(t, "my_credential", feed.Credential, "Get feed credential failed.")
			assert.Equal(t, 2, len(feed.Operations), "Get operations number failed.")
			for operation_name := range feed.Operations {
				switch operation_name {
				case "operation1":
				case "operation2":
				default:
					t.Error("Get feed operation name failed")
				}
			}
		default:
			t.Error("Get feed name failed")
		}
	}
}

func TestParseManifestYAML_param(t *testing.T) {
	data, err := ioutil.ReadFile(manifestfile6)
	if err != nil {
		panic(err)
	}

	var manifest parsers.ManifestYAML
	err = parsers.NewYAMLParser().Unmarshal(data, &manifest)
	if err != nil {
		panic(err)
	}

	assert.Equal(t, 1, len(manifest.Package.Actions), "Get action list failed.")
	for action_name := range manifest.Package.Actions {
		var action = manifest.Package.Actions[action_name]
		switch action_name {
		case "action1":
			for param_name := range action.Inputs {
				var param = action.Inputs[param_name]
				switch param_name {
				case "inline1":
					assert.Equal(t, "{ \"key\": true }", param.Value, "Get param value failed.")
				case "inline2":
					assert.Equal(t, "Just a string", param.Value, "Get param value failed.")
				case "inline3":
					assert.Equal(t, nil, param.Value, "Get param value failed.")
				case "inline4":
					assert.Equal(t, true, param.Value, "Get param value failed.")
				case "inline5":
					assert.Equal(t, 42, param.Value, "Get param value failed.")
				case "inline6":
					assert.Equal(t, -531, param.Value, "Get param value failed.")
				case "inline7":
					assert.Equal(t, 432.432E-43, param.Value, "Get param value failed.")
				case "inline8":
					assert.Equal(t, "[ true, null, \"boo\", { \"key\": 0 }]", param.Value, "Get param value failed.")
				case "inline9":
					assert.Equal(t, false, param.Value, "Get param value failed.")
				case "inline0":
					assert.Equal(t, 456.423, param.Value, "Get param value failed.")
				case "inlin10":
					assert.Equal(t, nil, param.Value, "Get param value failed.")
				case "inlin11":
					assert.Equal(t, true, param.Value, "Get param value failed.")
				case "expand1":
					assert.Equal(t, nil, param.Value, "Get param value failed.")
				case "expand2":
					assert.Equal(t, true, param.Value, "Get param value failed.")
				case "expand3":
					assert.Equal(t, false, param.Value, "Get param value failed.")
				case "expand4":
					assert.Equal(t, 15646, param.Value, "Get param value failed.")
				case "expand5":
					assert.Equal(t, "{ \"key\": true }", param.Value, "Get param value failed.")
				case "expand6":
					assert.Equal(t, "[ true, null, \"boo\", { \"key\": 0 }]", param.Value, "Get param value failed.")
				case "expand7":
					assert.Equal(t, nil, param.Value, "Get param value failed.")
				default:
					t.Error("Get param name failed")
				}
			}
		default:
			t.Error("Get action name failed")
		}
	}
}

func TestParseDeploymentYAML_Application(t *testing.T) {
	//var deployment utils.DeploymentYAML
	mm := parsers.NewYAMLParser()
	deployment := mm.ParseDeployment(testfile1)

	//get and verify application name
	assert.Equal(t, "wskdeploy-samples", deployment.Application.Name, "Get application name failed.")
	assert.Equal(t, "/wskdeploy/samples/", deployment.Application.Namespace, "Get application namespace failed.")
	assert.Equal(t, "user-credential", deployment.Application.Credential, "Get application credential failed.")
	assert.Equal(t, "https://172.17.0.1/api", deployment.Application.BaseUrl, "Get application base url failed.")
}

func TestParseDeploymentYAML_Package(t *testing.T) {
	//var deployment utils.DeploymentYAML
	mm := parsers.NewYAMLParser()
	deployment := mm.ParseDeployment(testfile2)

	assert.Equal(t, 1, len(deployment.Application.Packages), "Get package list failed.")
	for pkg_name := range deployment.Application.Packages {
		assert.Equal(t, "test_package", pkg_name, "Get package name failed.")
		var pkg = deployment.Application.Packages[pkg_name]
		assert.Equal(t, "http://abc.com/bbb", pkg.Function, "Get package function failed.")
		assert.Equal(t, "12345678ABCDEF", pkg.PackageCredential, "Get package credential failed.")
		assert.Equal(t, "/wskdeploy/samples/test", pkg.Namespace, "Get package namespace failed.")
		assert.Equal(t, "12345678ABCDEF", pkg.Credential, "Get package credential failed.")
		assert.Equal(t, 1, len(pkg.Inputs), "Get package input list failed.")
		//get and verify inputs
		for param_name, param := range pkg.Inputs {
			assert.Equal(t, "value", param.Value, "Get input value failed.")
			assert.Equal(t, "param", param_name, "Get input param name failed.")
		}
	}
}

func TestParseDeploymentYAML_Action(t *testing.T) {
	mm := parsers.NewYAMLParser()
	deployment := mm.ParseDeployment(testfile2)

	for pkg_name := range deployment.Application.Packages {

		var pkg = deployment.Application.Packages[pkg_name]
		for action_name := range pkg.Actions {
			assert.Equal(t, "hello", action_name, "Get action name failed.")
			var action = pkg.Actions[action_name]
			assert.Equal(t, "/wskdeploy/samples/test/hello", action.Namespace, "Get action namespace failed.")
			assert.Equal(t, "12345678ABCDEF", action.Credential, "Get action credential failed.")
			assert.Equal(t, 1, len(action.Inputs), "Get package input list failed.")
			//get and verify inputs
			for param_name, param := range action.Inputs {
				switch param.Value.(type) {
				case string:
					assert.Equal(t, "name", param_name, "Get input param name failed.")
					assert.Equal(t, "Bernie", param.Value, "Get input value failed.")
				default:
					t.Error("Get input value type failed.")
				}
			}
		}
	}
}

func TestComposeWskPackage(t *testing.T) {
	mm := parsers.NewYAMLParser()
	deployment := mm.ParseDeployment(testfile2)
	manifest := mm.ParseManifest(manifestfile1)

	pkglist := deployment.Application.GetPackageList()
	for _, pkg := range pkglist {
		wskpkg := pkg.ComposeWskPackage()
		assert.Equal(t, "test_package", wskpkg.Name, "Get package name failed.")
		assert.Equal(t, "/wskdeploy/samples/test", wskpkg.Namespace, "Get package namespace failed.")
	}

	pkg := manifest.Package
	wskpkg := pkg.ComposeWskPackage()
	assert.Equal(t, "helloworld", wskpkg.Name, "Get package name failed.")
	assert.Equal(t, "1.0", wskpkg.Version, "Get package version failed.")
}

func TestComposeWskTrigger(t *testing.T) {
	mm := parsers.NewYAMLParser()
	deployment := mm.ParseDeployment(testfile4)
	manifest := mm.ParseManifest(manifestfile3)

	pkg := deployment.Application.GetPackageList()[0]
	for _, trigger := range pkg.GetTriggerList() {
		//temporarily add the nil to make test pass, as we plan refactor the parser as well as test codes.
		wsktrigger := trigger.ComposeWskTrigger(nil)
		assert.Equal(t, "hello-trigger", wsktrigger.Name, "Get trigger name failed.")
		assert.Equal(t, "/wskdeploy/samples/test/hello-trigger", wsktrigger.Namespace, "Get trigger namespace failed.")
	}

	pkg = manifest.Package
	for _, trigger := range pkg.GetTriggerList() {
		//temporarily add the nil to make test pass, as we plan refactor the parser as well as test codes.
		wsktrigger := trigger.ComposeWskTrigger(nil)
		switch wsktrigger.Name {
		case "trigger1":
		case "trigger2":
		default:
			t.Error("Get trigger name failed")
		}
	}
}

func TestComposeWskRule(t *testing.T) {
	mm := parsers.NewYAMLParser()
	manifest := mm.ParseManifest(manifestfile4)

	pkg := manifest.Package
	for _, rule := range pkg.GetRuleList() {
		wskrule := rule.ComposeWskRule()
		switch wskrule.Name {
		case "rule1":
			assert.Equal(t, "trigger1", wskrule.Trigger, "Get rule trigger failed.")
			assert.Equal(t, "hellpworld", wskrule.Action, "Get rule action failed.")
		default:
			t.Error("Get rule name failed")
		}
	}
}