// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package typeparams_test

import (
	"go/ast"
	"go/parser"
	"go/token"
	"go/types"
	"strings"
	"testing"

	. "golang.org/x/tools/internal/typeparams"
)

func TestNormalize(t *testing.T) {
	if !Enabled {
		t.Skip("typeparams are not enabled")
	}
	tests := []struct {
		src       string
		want      string
		wantError string
	}{
		{"package emptyinterface0; type T interface{}", "interface{}", ""},
		{"package emptyinterface1; type T interface{ int | interface{} }", "interface{}", ""},
		{"package singleton; type T interface{ int }", "interface{int}", ""},
		{"package under; type T interface{~int}", "interface{~int}", ""},
		{"package superset; type T interface{ ~int | int }", "interface{~int}", ""},
		{"package overlap; type T interface{ ~int; int }", "interface{int}", ""},
		{"package emptyintersection; type T interface{ ~int; string }", "nil", ""},

		// The type-checker now produces Typ[Invalid] here (golang/go#48819).
		// TODO(rfindley): can we still test the cycle logic?
		// {"package cycle0; type T interface{ T }", "", "cycle"},
		// {"package cycle1; type T interface{ int | T }", "", "cycle"},
		// {"package cycle2; type T interface{ I }; type I interface { T }", "", "cycle"},

		{"package embedded0; type T interface{ I }; type I interface { int }", "interface{int}", ""},
		{"package embedded1; type T interface{ I | string }; type I interface{ int | ~string }", "interface{int|~string}", ""},
		{"package embedded2; type T interface{ I; string }; type I interface{ int | ~string }", "interface{string}", ""},
	}

	for _, test := range tests {
		fset := token.NewFileSet()
		f, err := parser.ParseFile(fset, "p.go", test.src, 0)
		if err != nil {
			t.Fatal(err)
		}
		t.Run(f.Name.Name, func(t *testing.T) {
			conf := types.Config{
				Error: func(error) {}, // keep going on errors
			}
			pkg, err := conf.Check("", fset, []*ast.File{f}, nil)
			if err != nil {
				t.Logf("types.Config.Check: %v", err)
				// keep going on type checker errors: we want to assert on behavior of
				// invalid code as well.
			}
			obj := pkg.Scope().Lookup("T")
			if obj == nil {
				t.Fatal("type T not found")
			}
			T := obj.Type().Underlying().(*types.Interface)
			normal, err := NormalizeInterface(T)
			if test.wantError != "" {
				if err == nil {
					t.Fatalf("Normalize(%s): nil error, want %q", T, test.wantError)
				}
				if !strings.Contains(err.Error(), test.wantError) {
					t.Errorf("Normalize(%s): err = %q, want %q", T, err, test.wantError)
				}
				return
			}
			if err != nil {
				t.Fatal(err)
			}
			qf := types.RelativeTo(pkg)
			var got string
			if normal == nil {
				got = "nil"
			} else {
				got = types.TypeString(normal, qf)
			}
			if got != test.want {
				t.Errorf("Normalize(%s) = %q, want %q", T, got, test.want)
			}
		})
	}
}