package integrationtest

import (
	"reflect"
	"sort"
	"testing"

	"github.com/davecgh/go-spew/spew"
	"github.com/hashicorp/hcl/v2"
	"github.com/hashicorp/hcl/v2/ext/dynblock"
	"github.com/hashicorp/hcl/v2/gohcl"
	"github.com/hashicorp/hcl/v2/hcldec"
	"github.com/hashicorp/hcl/v2/hclsyntax"
	"github.com/hashicorp/hcl/v2/json"
	"github.com/zclconf/go-cty/cty"
)

// TestTerraformLike parses both a native syntax and a JSON representation
// of the same HashiCorp Terraform-like configuration structure and then makes
// assertions against the result of each.
//
// Terraform exercises a lot of different HCL codepaths, so this is not
// exhaustive but tries to cover a variety of different relevant scenarios.
func TestTerraformLike(t *testing.T) {
	tests := map[string]func() (*hcl.File, hcl.Diagnostics){
		"native syntax": func() (*hcl.File, hcl.Diagnostics) {
			return hclsyntax.ParseConfig(
				[]byte(terraformLikeNativeSyntax),
				"config.tf", hcl.Pos{Line: 1, Column: 1},
			)
		},
		"JSON": func() (*hcl.File, hcl.Diagnostics) {
			return json.Parse(
				[]byte(terraformLikeJSON),
				"config.tf.json",
			)
		},
	}

	type Variable struct {
		Name string `hcl:"name,label"`
	}
	type Resource struct {
		Type      string         `hcl:"type,label"`
		Name      string         `hcl:"name,label"`
		Config    hcl.Body       `hcl:",remain"`
		DependsOn hcl.Expression `hcl:"depends_on,attr"`
	}
	type Module struct {
		Name      string         `hcl:"name,label"`
		Providers hcl.Expression `hcl:"providers"`
	}
	type Root struct {
		Variables []*Variable `hcl:"variable,block"`
		Resources []*Resource `hcl:"resource,block"`
		Modules   []*Module   `hcl:"module,block"`
	}
	instanceDecode := &hcldec.ObjectSpec{
		"image_id": &hcldec.AttrSpec{
			Name:     "image_id",
			Required: true,
			Type:     cty.String,
		},
		"instance_type": &hcldec.AttrSpec{
			Name:     "instance_type",
			Required: true,
			Type:     cty.String,
		},
		"tags": &hcldec.AttrSpec{
			Name:     "tags",
			Required: false,
			Type:     cty.Map(cty.String),
		},
	}
	securityGroupDecode := &hcldec.ObjectSpec{
		"ingress": &hcldec.BlockListSpec{
			TypeName: "ingress",
			Nested: &hcldec.ObjectSpec{
				"cidr_block": &hcldec.AttrSpec{
					Name:     "cidr_block",
					Required: true,
					Type:     cty.String,
				},
			},
		},
	}

	for name, loadFunc := range tests {
		t.Run(name, func(t *testing.T) {
			file, diags := loadFunc()
			if len(diags) != 0 {
				t.Errorf("unexpected diagnostics during parse")
				for _, diag := range diags {
					t.Logf("- %s", diag)
				}
				return
			}

			body := file.Body

			var root Root
			diags = gohcl.DecodeBody(body, nil, &root)
			if len(diags) != 0 {
				t.Errorf("unexpected diagnostics during root eval")
				for _, diag := range diags {
					t.Logf("- %s", diag)
				}
				return
			}

			wantVars := []*Variable{
				{
					Name: "image_id",
				},
			}
			if gotVars := root.Variables; !reflect.DeepEqual(gotVars, wantVars) {
				t.Errorf("wrong Variables\ngot:  %swant: %s", spew.Sdump(gotVars), spew.Sdump(wantVars))
			}

			if got, want := len(root.Resources), 3; got != want {
				t.Fatalf("wrong number of Resources %d; want %d", got, want)
			}

			sort.Slice(root.Resources, func(i, j int) bool {
				return root.Resources[i].Name < root.Resources[j].Name
			})

			t.Run("resource 0", func(t *testing.T) {
				r := root.Resources[0]
				if got, want := r.Type, "happycloud_security_group"; got != want {
					t.Errorf("wrong type %q; want %q", got, want)
				}
				if got, want := r.Name, "private"; got != want {
					t.Errorf("wrong type %q; want %q", got, want)
				}

				// For this one we're including support for the dynamic block
				// extension, since Terraform uses this to allow dynamic
				// generation of blocks within resource configuration.
				forEachCtx := &hcl.EvalContext{
					Variables: map[string]cty.Value{
						"var": cty.ObjectVal(map[string]cty.Value{
							"extra_private_cidr_blocks": cty.ListVal([]cty.Value{
								cty.StringVal("172.16.0.0/12"),
								cty.StringVal("169.254.0.0/16"),
							}),
						}),
					},
				}
				dynBody := dynblock.Expand(r.Config, forEachCtx)

				cfg, diags := hcldec.Decode(dynBody, securityGroupDecode, nil)
				if len(diags) != 0 {
					t.Errorf("unexpected diagnostics decoding Config")
					for _, diag := range diags {
						t.Logf("- %s", diag)
					}
					return
				}
				wantCfg := cty.ObjectVal(map[string]cty.Value{
					"ingress": cty.ListVal([]cty.Value{
						cty.ObjectVal(map[string]cty.Value{
							"cidr_block": cty.StringVal("10.0.0.0/8"),
						}),
						cty.ObjectVal(map[string]cty.Value{
							"cidr_block": cty.StringVal("192.168.0.0/16"),
						}),
						cty.ObjectVal(map[string]cty.Value{
							"cidr_block": cty.StringVal("172.16.0.0/12"),
						}),
						cty.ObjectVal(map[string]cty.Value{
							"cidr_block": cty.StringVal("169.254.0.0/16"),
						}),
					}),
				})
				if !cfg.RawEquals(wantCfg) {
					t.Errorf("wrong config\ngot:  %#v\nwant: %#v", cfg, wantCfg)
				}
			})

			t.Run("resource 1", func(t *testing.T) {
				r := root.Resources[1]
				if got, want := r.Type, "happycloud_security_group"; got != want {
					t.Errorf("wrong type %q; want %q", got, want)
				}
				if got, want := r.Name, "public"; got != want {
					t.Errorf("wrong type %q; want %q", got, want)
				}

				cfg, diags := hcldec.Decode(r.Config, securityGroupDecode, nil)
				if len(diags) != 0 {
					t.Errorf("unexpected diagnostics decoding Config")
					for _, diag := range diags {
						t.Logf("- %s", diag)
					}
					return
				}
				wantCfg := cty.ObjectVal(map[string]cty.Value{
					"ingress": cty.ListVal([]cty.Value{
						cty.ObjectVal(map[string]cty.Value{
							"cidr_block": cty.StringVal("0.0.0.0/0"),
						}),
					}),
				})
				if !cfg.RawEquals(wantCfg) {
					t.Errorf("wrong config\ngot:  %#v\nwant: %#v", cfg, wantCfg)
				}
			})

			t.Run("resource 2", func(t *testing.T) {
				r := root.Resources[2]
				if got, want := r.Type, "happycloud_instance"; got != want {
					t.Errorf("wrong type %q; want %q", got, want)
				}
				if got, want := r.Name, "test"; got != want {
					t.Errorf("wrong type %q; want %q", got, want)
				}

				vars := hcldec.Variables(r.Config, &hcldec.AttrSpec{
					Name: "image_id",
					Type: cty.String,
				})
				if got, want := len(vars), 1; got != want {
					t.Errorf("wrong number of variables in image_id %#v; want %#v", got, want)
				}
				if got, want := vars[0].RootName(), "var"; got != want {
					t.Errorf("wrong image_id variable RootName %#v; want %#v", got, want)
				}

				ctx := &hcl.EvalContext{
					Variables: map[string]cty.Value{
						"var": cty.ObjectVal(map[string]cty.Value{
							"image_id": cty.StringVal("image-1234"),
						}),
					},
				}
				cfg, diags := hcldec.Decode(r.Config, instanceDecode, ctx)
				if len(diags) != 0 {
					t.Errorf("unexpected diagnostics decoding Config")
					for _, diag := range diags {
						t.Logf("- %s", diag)
					}
					return
				}
				wantCfg := cty.ObjectVal(map[string]cty.Value{
					"instance_type": cty.StringVal("z3.weedy"),
					"image_id":      cty.StringVal("image-1234"),
					"tags": cty.MapVal(map[string]cty.Value{
						"Name":        cty.StringVal("foo"),
						"Environment": cty.StringVal("prod"),
					}),
				})
				if !cfg.RawEquals(wantCfg) {
					t.Errorf("wrong config\ngot:  %#v\nwant: %#v", cfg, wantCfg)
				}

				exprs, diags := hcl.ExprList(r.DependsOn)
				if len(diags) != 0 {
					t.Errorf("unexpected diagnostics extracting depends_on")
					for _, diag := range diags {
						t.Logf("- %s", diag)
					}
					return
				}
				if got, want := len(exprs), 1; got != want {
					t.Errorf("wrong number of depends_on exprs %#v; want %#v", got, want)
				}

				traversal, diags := hcl.AbsTraversalForExpr(exprs[0])
				if len(diags) != 0 {
					t.Errorf("unexpected diagnostics decoding depends_on[0]")
					for _, diag := range diags {
						t.Logf("- %s", diag)
					}
					return
				}
				if got, want := len(traversal), 2; got != want {
					t.Errorf("wrong number of depends_on traversal steps %#v; want %#v", got, want)
				}
				if got, want := traversal.RootName(), "happycloud_security_group"; got != want {
					t.Errorf("wrong depends_on traversal RootName %#v; want %#v", got, want)
				}
			})

			t.Run("module", func(t *testing.T) {
				if got, want := len(root.Modules), 1; got != want {
					t.Fatalf("wrong number of Modules %d; want %d", got, want)
				}
				mod := root.Modules[0]
				if got, want := mod.Name, "foo"; got != want {
					t.Errorf("wrong module name %q; want %q", got, want)
				}

				pExpr := mod.Providers
				pairs, diags := hcl.ExprMap(pExpr)
				if len(diags) != 0 {
					t.Errorf("unexpected diagnostics extracting providers")
					for _, diag := range diags {
						t.Logf("- %s", diag)
					}
				}
				if got, want := len(pairs), 1; got != want {
					t.Fatalf("wrong number of key/value pairs in providers %d; want %d", got, want)
				}

				pair := pairs[0]
				kt, diags := hcl.AbsTraversalForExpr(pair.Key)
				if len(diags) != 0 {
					t.Errorf("unexpected diagnostics extracting providers key %#v", pair.Key)
					for _, diag := range diags {
						t.Logf("- %s", diag)
					}
				}
				vt, diags := hcl.AbsTraversalForExpr(pair.Value)
				if len(diags) != 0 {
					t.Errorf("unexpected diagnostics extracting providers value  %#v", pair.Value)
					for _, diag := range diags {
						t.Logf("- %s", diag)
					}
				}

				if got, want := len(kt), 1; got != want {
					t.Fatalf("wrong number of key traversal steps %d; want %d", got, want)
				}
				if got, want := len(vt), 2; got != want {
					t.Fatalf("wrong number of value traversal steps %d; want %d", got, want)
				}

				if got, want := kt.RootName(), "null"; got != want {
					t.Errorf("wrong number key traversal root %s; want %s", got, want)
				}
				if got, want := vt.RootName(), "null"; got != want {
					t.Errorf("wrong number value traversal root %s; want %s", got, want)
				}
				if at, ok := vt[1].(hcl.TraverseAttr); ok {
					if got, want := at.Name, "foo"; got != want {
						t.Errorf("wrong number value traversal attribute name %s; want %s", got, want)
					}
				} else {
					t.Errorf("wrong value traversal [1] type %T; want hcl.TraverseAttr", vt[1])
				}
			})
		})
	}
}

const terraformLikeNativeSyntax = `

variable "image_id" {
}

resource "happycloud_instance" "test" {
  instance_type = "z3.weedy"
  image_id      = var.image_id

  tags = {
  "Name" = "foo"
  "${"Environment"}" = "prod"
  }

  depends_on = [
    happycloud_security_group.public,
  ]
}

resource "happycloud_security_group" "public" {
  ingress {
    cidr_block = "0.0.0.0/0"
  }
}

resource "happycloud_security_group" "private" {
  ingress {
    cidr_block = "10.0.0.0/8"
  }
  ingress {
    cidr_block = "192.168.0.0/16"
  }
  dynamic "ingress" {
    for_each = var.extra_private_cidr_blocks
    content {
      cidr_block = ingress.value
    }
  }
}

module "foo" {
  providers = {
    null = null.foo
  }
}

`

const terraformLikeJSON = `
{
  "variable": {
    "image_id": {}
  },
  "resource": {
    "happycloud_instance": {
      "test": {
        "instance_type": "z3.weedy",
        "image_id": "${var.image_id}",
        "tags": {
            "Name": "foo",
            "${\"Environment\"}": "prod"
        },
        "depends_on": [
          "happycloud_security_group.public"
        ]
      }
    },
    "happycloud_security_group": {
      "public": {
        "ingress": {
          "cidr_block": "0.0.0.0/0"
        }
      },
      "private": {
        "ingress": [
          {
            "cidr_block": "10.0.0.0/8"
          },
          {
            "cidr_block": "192.168.0.0/16"
          }
        ],
        "dynamic": {
          "ingress": {
            "for_each": "${var.extra_private_cidr_blocks}",
            "iterator": "block",
            "content": {
              "cidr_block": "${block.value}"
            }
          }
        }
      }
    }
  },
  "module": {
    "foo": {
      "providers": {
        "null": "null.foo"
      }
    }
  }
}
`