package parser

import (
	"fmt"
	"io/ioutil"
	"path/filepath"
	"reflect"
	"runtime"
	"strings"
	"testing"

	"github.com/hashicorp/hcl/hcl/ast"
	"github.com/hashicorp/hcl/hcl/token"
)

func TestType(t *testing.T) {
	var literals = []struct {
		typ token.Type
		src string
	}{
		{token.STRING, `foo = "foo"`},
		{token.NUMBER, `foo = 123`},
		{token.NUMBER, `foo = -29`},
		{token.FLOAT, `foo = 123.12`},
		{token.FLOAT, `foo = -123.12`},
		{token.BOOL, `foo = true`},
		{token.HEREDOC, "foo = <<EOF\nHello\nWorld\nEOF"},
	}

	for _, l := range literals {
		p := newParser([]byte(l.src), true)
		item, err := p.objectItem()
		if err != nil {
			t.Error(err)
		}

		lit, ok := item.Val.(*ast.LiteralType)
		if !ok {
			t.Errorf("node should be of type LiteralType, got: %T", item.Val)
		}

		if lit.Token.Type != l.typ {
			t.Errorf("want: %s, got: %s", l.typ, lit.Token.Type)
		}
	}
}

func TestListType(t *testing.T) {
	var literals = []struct {
		src    string
		tokens []token.Type
	}{
		{
			`foo = ["123", 123]`,
			[]token.Type{token.STRING, token.NUMBER},
		},
		{
			`foo = [123, "123",]`,
			[]token.Type{token.NUMBER, token.STRING},
		},
		{
			`foo = [false]`,
			[]token.Type{token.BOOL},
		},
		{
			`foo = []`,
			[]token.Type{},
		},
		{
			`foo = [1,
"string",
<<EOF
heredoc contents
EOF
]`,
			[]token.Type{token.NUMBER, token.STRING, token.HEREDOC},
		},
	}

	for _, l := range literals {
		p := newParser([]byte(l.src), true)
		item, err := p.objectItem()
		if err != nil {
			t.Error(err)
		}

		list, ok := item.Val.(*ast.ListType)
		if !ok {
			t.Errorf("node should be of type LiteralType, got: %T", item.Val)
		}

		tokens := []token.Type{}
		for _, li := range list.List {
			if tp, ok := li.(*ast.LiteralType); ok {
				tokens = append(tokens, tp.Token.Type)
			}
		}

		equals(t, l.tokens, tokens)
	}
}

func TestListOfMaps(t *testing.T) {
	src := `foo = [
    {key = "bar"},
    {key = "baz", key2 = "qux"},
  ]`
	p := newParser([]byte(src), true)

	file, err := p.Parse()
	if err != nil {
		t.Fatalf("err: %s", err)
	}

	// Here we make all sorts of assumptions about the input structure w/ type
	// assertions. The intent is only for this to be a "smoke test" ensuring
	// parsing actually performed its duty - giving this test something a bit
	// more robust than _just_ "no error occurred".
	expected := []string{`"bar"`, `"baz"`, `"qux"`}
	actual := make([]string, 0, 3)
	ol := file.Node.(*ast.ObjectList)
	objItem := ol.Items[0]
	list := objItem.Val.(*ast.ListType)
	for _, node := range list.List {
		obj := node.(*ast.ObjectType)
		for _, item := range obj.List.Items {
			val := item.Val.(*ast.LiteralType)
			actual = append(actual, val.Token.Text)
		}

	}
	if !reflect.DeepEqual(expected, actual) {
		t.Fatalf("Expected: %#v, got %#v", expected, actual)
	}
}

func TestDuplicateKeys_NotAllowed(t *testing.T) {
	src := `key = "value1"
			key = "value2"
  `
	p := newParser([]byte(src), true)

	_, err := p.Parse()
	if err == nil {
		t.Fatalf("Expected error, got none!")
	}

	expected := "Each argument can only be defined once"
	if !strings.Contains(err.Error(), expected) {
		t.Fatalf("Expected err:\n  %s\nTo contain:\n  %s\n", err, expected)
	}
}

func TestDuplicateKeys_DontErrorWhenErrorOnDuplicateKeysIsFalse(t *testing.T) {
	src := `key = "value1"
			key = "value2"
  `
	p := newParser([]byte(src), false)

	_, err := p.Parse()
	if err != nil {
		t.Fatalf("Unexpected error " + err.Error())
	}
}

func TestDuplicateKeys_NotAllowedInBlock(t *testing.T) {
	src := `key = "value1"
			structkey "structname" { name = "test" name = "test2"}
  `
	p := newParser([]byte(src), true)

	_, err := p.Parse()
	if err == nil {
		t.Fatalf("Expected error, got none!")
	}

	expected := "Each argument can only be defined once"
	if !strings.Contains(err.Error(), expected) {
		t.Fatalf("Expected err:\n  %s\nTo contain:\n  %s\n", err, expected)
	}
}

func TestDuplicateBlocks_allowed(t *testing.T) {
	src := `structkey  { name = "test" }
			structkey  { name = "test" }`
	p := newParser([]byte(src), true)

	_, err := p.Parse()
	if err != nil {
		t.Fatalf(err.Error())
	}

}

func TestListOfMaps_requiresComma(t *testing.T) {
	src := `foo = [
    {key = "bar"}
    {key = "baz"}
  ]`
	p := newParser([]byte(src), true)

	_, err := p.Parse()
	if err == nil {
		t.Fatalf("Expected error, got none!")
	}

	expected := "error parsing list, expected comma or list end"
	if !strings.Contains(err.Error(), expected) {
		t.Fatalf("Expected err:\n  %s\nTo contain:\n  %s\n", err, expected)
	}
}

func TestListType_leadComment(t *testing.T) {
	var literals = []struct {
		src     string
		comment []string
	}{
		{
			`foo = [
			1,
			# bar
			2,
			3,
			]`,
			[]string{"", "# bar", ""},
		},
	}

	for _, l := range literals {
		p := newParser([]byte(l.src), true)
		item, err := p.objectItem()
		if err != nil {
			t.Fatal(err)
		}

		list, ok := item.Val.(*ast.ListType)
		if !ok {
			t.Fatalf("node should be of type LiteralType, got: %T", item.Val)
		}

		if len(list.List) != len(l.comment) {
			t.Fatalf("bad: %d", len(list.List))
		}

		for i, li := range list.List {
			lt := li.(*ast.LiteralType)
			comment := l.comment[i]

			if (lt.LeadComment == nil) != (comment == "") {
				t.Fatalf("bad: %#v", lt)
			}

			if comment == "" {
				continue
			}

			actual := lt.LeadComment.List[0].Text
			if actual != comment {
				t.Fatalf("bad: %q %q", actual, comment)
			}
		}
	}
}

func TestListType_lineComment(t *testing.T) {
	var literals = []struct {
		src     string
		comment []string
	}{
		{
			`foo = [
			1,
			2, # bar
			3,
			]`,
			[]string{"", "# bar", ""},
		},
	}

	for _, l := range literals {
		p := newParser([]byte(l.src), true)
		item, err := p.objectItem()
		if err != nil {
			t.Fatal(err)
		}

		list, ok := item.Val.(*ast.ListType)
		if !ok {
			t.Fatalf("node should be of type LiteralType, got: %T", item.Val)
		}

		if len(list.List) != len(l.comment) {
			t.Fatalf("bad: %d", len(list.List))
		}

		for i, li := range list.List {
			lt := li.(*ast.LiteralType)
			comment := l.comment[i]

			if (lt.LineComment == nil) != (comment == "") {
				t.Fatalf("bad: %v", lt)
			}

			if comment == "" {
				continue
			}

			actual := lt.LineComment.List[0].Text
			if actual != comment {
				t.Fatalf("bad: %q %q", actual, comment)
			}
		}
	}
}

func TestObjectType(t *testing.T) {
	var literals = []struct {
		src      string
		nodeType []ast.Node
		itemLen  int
	}{
		{
			`foo = {}`,
			nil,
			0,
		},
		{
			`foo = {
				bar = "fatih"
			 }`,
			[]ast.Node{&ast.LiteralType{}},
			1,
		},
		{
			`foo = {
				bar = "fatih"
				baz = ["arslan"]
			 }`,
			[]ast.Node{
				&ast.LiteralType{},
				&ast.ListType{},
			},
			2,
		},
		{
			`foo = {
				bar {}
			 }`,
			[]ast.Node{
				&ast.ObjectType{},
			},
			1,
		},
		{
			`foo {
				bar {}
				foo = true
			 }`,
			[]ast.Node{
				&ast.ObjectType{},
				&ast.LiteralType{},
			},
			2,
		},
	}

	for _, l := range literals {
		t.Logf("Source: %s", l.src)

		p := newParser([]byte(l.src), true)
		// p.enableTrace = true
		item, err := p.objectItem()
		if err != nil {
			t.Error(err)
			continue
		}

		// we know that the ObjectKey name is foo for all cases, what matters
		// is the object
		obj, ok := item.Val.(*ast.ObjectType)
		if !ok {
			t.Errorf("node should be of type LiteralType, got: %T", item.Val)
			continue
		}

		// check if the total length of items are correct
		equals(t, l.itemLen, len(obj.List.Items))

		// check if the types are correct
		for i, item := range obj.List.Items {
			equals(t, reflect.TypeOf(l.nodeType[i]), reflect.TypeOf(item.Val))
		}
	}
}

func TestObjectKey(t *testing.T) {
	keys := []struct {
		exp []token.Type
		src string
	}{
		{[]token.Type{token.IDENT}, `foo {}`},
		{[]token.Type{token.IDENT}, `foo = {}`},
		{[]token.Type{token.IDENT}, `foo = bar`},
		{[]token.Type{token.IDENT}, `foo = 123`},
		{[]token.Type{token.IDENT}, `foo = "${var.bar}`},
		{[]token.Type{token.STRING}, `"foo" {}`},
		{[]token.Type{token.STRING}, `"foo" = {}`},
		{[]token.Type{token.STRING}, `"foo" = "${var.bar}`},
		{[]token.Type{token.IDENT, token.IDENT}, `foo bar {}`},
		{[]token.Type{token.IDENT, token.STRING}, `foo "bar" {}`},
		{[]token.Type{token.STRING, token.IDENT}, `"foo" bar {}`},
		{[]token.Type{token.IDENT, token.IDENT, token.IDENT}, `foo bar baz {}`},
	}

	for _, k := range keys {
		p := newParser([]byte(k.src), true)
		keys, err := p.objectKey()
		if err != nil {
			t.Fatal(err)
		}

		tokens := []token.Type{}
		for _, o := range keys {
			tokens = append(tokens, o.Token.Type)
		}

		equals(t, k.exp, tokens)
	}

	errKeys := []struct {
		src string
	}{
		{`foo 12 {}`},
		{`foo bar = {}`},
		{`foo []`},
		{`12 {}`},
	}

	for _, k := range errKeys {
		p := newParser([]byte(k.src), true)
		_, err := p.objectKey()
		if err == nil {
			t.Errorf("case '%s' should give an error", k.src)
		}
	}
}

func TestCommentGroup(t *testing.T) {
	var cases = []struct {
		src    string
		groups int
	}{
		{"# Hello\n# World", 1},
		{"# Hello\r\n# Windows", 1},
	}

	for _, tc := range cases {
		t.Run(tc.src, func(t *testing.T) {
			p := newParser([]byte(tc.src), true)
			file, err := p.Parse()
			if err != nil {
				t.Fatalf("parse error: %s", err)
			}

			if len(file.Comments) != tc.groups {
				t.Fatalf("bad: %#v", file.Comments)
			}
		})
	}
}

// Official HCL tests
func TestParse(t *testing.T) {
	cases := []struct {
		Name string
		Err  bool
	}{
		{
			"assign_colon.hcl",
			true,
		},
		{
			"comment.hcl",
			false,
		},
		{
			"comment_crlf.hcl",
			false,
		},
		{
			"comment_lastline.hcl",
			false,
		},
		{
			"comment_single.hcl",
			false,
		},
		{
			"empty.hcl",
			false,
		},
		{
			"list_comma.hcl",
			false,
		},
		{
			"multiple.hcl",
			false,
		},
		{
			"object_list_comma.hcl",
			false,
		},
		{
			"structure.hcl",
			false,
		},
		{
			"structure_basic.hcl",
			false,
		},
		{
			"structure_empty.hcl",
			false,
		},
		{
			"complex.hcl",
			false,
		},
		{
			"complex_crlf.hcl",
			false,
		},
		{
			"types.hcl",
			false,
		},
		{
			"array_comment.hcl",
			false,
		},
		{
			"array_comment_2.hcl",
			true,
		},
		{
			"missing_braces.hcl",
			true,
		},
		{
			"unterminated_object.hcl",
			true,
		},
		{
			"unterminated_object_2.hcl",
			true,
		},
		{
			"key_without_value.hcl",
			true,
		},
		{
			"object_key_without_value.hcl",
			true,
		},
		{
			"object_key_assign_without_value.hcl",
			true,
		},
		{
			"object_key_assign_without_value2.hcl",
			true,
		},
		{
			"object_key_assign_without_value3.hcl",
			true,
		},
		{
			"git_crypt.hcl",
			true,
		},
	}

	const fixtureDir = "./test-fixtures"

	for _, tc := range cases {
		t.Run(tc.Name, func(t *testing.T) {
			d, err := ioutil.ReadFile(filepath.Join(fixtureDir, tc.Name))
			if err != nil {
				t.Fatalf("err: %s", err)
			}

			v, err := Parse(d)
			if (err != nil) != tc.Err {
				t.Fatalf("Input: %s\n\nError: %s\n\nAST: %#v", tc.Name, err, v)
			}
		})
	}
}

func TestParse_inline(t *testing.T) {
	cases := []struct {
		Value string
		Err   bool
	}{
		{"t t e{{}}", true},
		{"o{{}}", true},
		{"t t e d N{{}}", true},
		{"t t e d{{}}", true},
		{"N{}N{{}}", true},
		{"v\nN{{}}", true},
		{"v=/\n[,", true},
		{"v=10kb", true},
		{"v=/foo", true},
	}

	for _, tc := range cases {
		t.Logf("Testing: %q", tc.Value)
		ast, err := Parse([]byte(tc.Value))
		if (err != nil) != tc.Err {
			t.Fatalf("Input: %q\n\nError: %s\n\nAST: %#v", tc.Value, err, ast)
		}
	}
}

// equals fails the test if exp is not equal to act.
func equals(tb testing.TB, exp, act interface{}) {
	if !reflect.DeepEqual(exp, act) {
		_, file, line, _ := runtime.Caller(1)
		fmt.Printf("\033[31m%s:%d:\n\n\texp: %#v\n\n\tgot: %#v\033[39m\n\n", filepath.Base(file), line, exp, act)
		tb.FailNow()
	}
}
