package printer_test

import (
	"testing"

	"efprojects.com/kitten-ipc/kitcom/internal/tsgo/ast"
	"efprojects.com/kitten-ipc/kitcom/internal/tsgo/binder"
	"efprojects.com/kitten-ipc/kitcom/internal/tsgo/printer"
	"efprojects.com/kitten-ipc/kitcom/internal/tsgo/testutil/parsetestutil"
	"gotest.tools/v3/assert"
)

func TestTempVariable1(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewTempVariable()
	name2 := ec.Factory.NewTempVariable()

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name2)

	assert.Equal(t, "_a", text1)
	assert.Equal(t, "_b", text2)
}

func TestTempVariable2(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewTempVariableEx(printer.AutoGenerateOptions{
		Prefix: "A",
		Suffix: "B",
	})
	name2 := ec.Factory.NewTempVariableEx(printer.AutoGenerateOptions{
		Prefix: "A",
		Suffix: "B",
	})

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name2)

	assert.Equal(t, "A_aB", text1)
	assert.Equal(t, "A_bB", text2)
}

func TestTempVariable3(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewTempVariable()

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name1)

	assert.Equal(t, "_a", text1)
	assert.Equal(t, "_a", text2)
}

func TestTempVariableScoped(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewTempVariable()
	name2 := ec.Factory.NewTempVariable()

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	g.PushScope(false)
	text2 := g.GenerateName(name2)
	g.PopScope(false)

	assert.Equal(t, "_a", text1)
	assert.Equal(t, "_a", text2)
}

func TestTempVariableScopedReserved(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewTempVariableEx(printer.AutoGenerateOptions{Flags: printer.GeneratedIdentifierFlagsReservedInNestedScopes})
	name2 := ec.Factory.NewTempVariable()

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	g.PushScope(false)
	text2 := g.GenerateName(name2)
	g.PopScope(false)

	assert.Equal(t, "_a", text1)
	assert.Equal(t, "_b", text2)
}

func TestLoopVariable1(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewLoopVariable()
	name2 := ec.Factory.NewLoopVariable()

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name2)

	assert.Equal(t, "_i", text1)
	assert.Equal(t, "_a", text2)
}

func TestLoopVariable2(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewLoopVariableEx(printer.AutoGenerateOptions{
		Prefix: "A",
		Suffix: "B",
	})
	name2 := ec.Factory.NewLoopVariableEx(printer.AutoGenerateOptions{
		Prefix: "A",
		Suffix: "B",
	})

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name2)

	assert.Equal(t, "A_iB", text1)
	assert.Equal(t, "A_aB", text2)
}

func TestLoopVariable3(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewLoopVariable()

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name1)

	assert.Equal(t, "_i", text1)
	assert.Equal(t, "_i", text2)
}

func TestLoopVariableScoped(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewLoopVariable()
	name2 := ec.Factory.NewLoopVariable()

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	g.PushScope(false)
	text2 := g.GenerateName(name2)
	g.PopScope(false)

	assert.Equal(t, "_i", text1)
	assert.Equal(t, "_i", text2)
}

func TestUniqueName1(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewUniqueName("foo")
	name2 := ec.Factory.NewUniqueName("foo")

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name2)

	assert.Equal(t, "foo_1", text1)
	assert.Equal(t, "foo_2", text2)
}

func TestUniqueName2(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewUniqueName("foo")

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name1)

	assert.Equal(t, "foo_1", text1)
	// Expected to be same because GenerateName goes off object identity
	assert.Equal(t, "foo_1", text2)
}

func TestUniqueNameScoped(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewUniqueName("foo")
	name2 := ec.Factory.NewUniqueName("foo")

	g := &printer.NameGenerator{Context: ec}
	assert.Equal(t, "foo_1", g.GenerateName(name1))

	g.PushScope(false)
	assert.Equal(t, "foo_2", g.GenerateName(name2)) // Matches Strada, but is incorrect
	// assert.Equal(t, "foo_1", g.GenerateName(name2)) // TODO: Fix after Strada port is complete.
	g.PopScope(false)
}

func TestUniquePrivateName1(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewUniquePrivateName("#foo")
	name2 := ec.Factory.NewUniquePrivateName("#foo")

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name2)

	assert.Equal(t, "#foo_1", text1)
	assert.Equal(t, "#foo_2", text2)
}

func TestUniquePrivateName2(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewUniquePrivateName("#foo")

	g := &printer.NameGenerator{Context: ec}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name1)

	assert.Equal(t, "#foo_1", text1)
	assert.Equal(t, "#foo_1", text2)
}

func TestUniquePrivateNameScoped(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()
	name1 := ec.Factory.NewUniquePrivateName("#foo")
	name2 := ec.Factory.NewUniquePrivateName("#foo")

	g := &printer.NameGenerator{Context: ec}
	assert.Equal(t, "#foo_1", g.GenerateName(name1))

	g.PushScope(false) // private names are always reserved in nested scopes
	assert.Equal(t, "#foo_2", g.GenerateName(name2))
	g.PopScope(false)
}

func TestGeneratedNameForIdentifier1(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("function f() {}", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0].Name()
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "f_1", text1)
}

func TestGeneratedNameForIdentifier2(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("function f() {}", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0].Name()
	name1 := ec.Factory.NewGeneratedNameForNodeEx(n, printer.AutoGenerateOptions{
		Prefix: "a",
		Suffix: "b",
	})

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "afb", text1)
}

func TestGeneratedNameForIdentifier3(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("function f() {}", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0].Name()
	name1 := ec.Factory.NewGeneratedNameForNodeEx(n, printer.AutoGenerateOptions{
		Prefix: "a",
		Suffix: "b",
	})
	name2 := ec.Factory.NewGeneratedNameForNode(name1)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name2)

	assert.Equal(t, "afb_1", text1)
}

// namespace reuses name if it does not collide with locals
func TestGeneratedNameForNamespace1(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("namespace foo { }", false /*jsx*/)
	binder.BindSourceFile(file)

	ns1 := file.Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(ns1)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "foo", text1)
}

// namespace uses generated name if it collides with locals
func TestGeneratedNameForNamespace2(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("namespace foo { var foo; }", false /*jsx*/)
	binder.BindSourceFile(file)

	ns1 := file.Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(ns1)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "foo_1", text1)
}

// avoids collisions when unscoped
func TestGeneratedNameForNamespace3(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("namespace ns1 { namespace foo { var foo; } } namespace ns2 { namespace foo { var foo; } }", false /*jsx*/)
	binder.BindSourceFile(file)

	ns1 := file.Statements.Nodes[0].AsModuleDeclaration().Body.AsModuleBlock().Statements.Nodes[0]
	ns2 := file.Statements.Nodes[1].AsModuleDeclaration().Body.AsModuleBlock().Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(ns1)
	name2 := ec.Factory.NewGeneratedNameForNode(ns2)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name2)

	assert.Equal(t, "foo_1", text1)
	assert.Equal(t, "foo_2", text2)
}

// reuse name when scoped
func TestGeneratedNameForNamespace4(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("namespace ns1 { namespace foo { var foo; } } namespace ns2 { namespace foo { var foo; } }", false /*jsx*/)
	binder.BindSourceFile(file)

	ns1 := file.Statements.Nodes[0].AsModuleDeclaration().Body.AsModuleBlock().Statements.Nodes[0]
	ns2 := file.Statements.Nodes[1].AsModuleDeclaration().Body.AsModuleBlock().Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(ns1)
	name2 := ec.Factory.NewGeneratedNameForNode(ns2)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	g.PushScope(false)
	text1 := g.GenerateName(name1)
	g.PopScope(false)

	g.PushScope(false)
	text2 := g.GenerateName(name2)
	g.PopScope(false)

	assert.Equal(t, "foo_1", text1)
	assert.Equal(t, "foo_2", text2) // Matches Strada, but is incorrect
	// assert.Equal(t, "foo_1", text2) // TODO: Fix after Strada port is complete.
}

func TestGeneratedNameForNodeCached(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("namespace foo { var foo; }", false /*jsx*/)
	binder.BindSourceFile(file)

	ns1 := file.Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(ns1)
	name2 := ec.Factory.NewGeneratedNameForNode(ns1)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)
	text2 := g.GenerateName(name2)

	assert.Equal(t, "foo_1", text1)
	assert.Equal(t, "foo_1", text2)
}

func TestGeneratedNameForImport(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("import * as foo from 'foo'", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "foo_1", text1)
}

func TestGeneratedNameForExport(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("export * as foo from 'foo'", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "foo_1", text1)
}

func TestGeneratedNameForFunctionDeclaration1(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("export function f() {}", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "f_1", text1)
}

func TestGeneratedNameForFunctionDeclaration2(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("export default function () {}", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "default_1", text1)
}

func TestGeneratedNameForClassDeclaration1(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("export class C {}", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "C_1", text1)
}

func TestGeneratedNameForClassDeclaration2(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("export default class {}", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "default_1", text1)
}

func TestGeneratedNameForExportAssignment(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("export default 0", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "default_1", text1)
}

func TestGeneratedNameForClassExpression(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("(class {})", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0].AsExpressionStatement().Expression.AsParenthesizedExpression().Expression
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "class_1", text1)
}

func TestGeneratedNameForMethod1(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("class C { m() {} }", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0].AsClassDeclaration().Members.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "m_1", text1)
}

func TestGeneratedNameForMethod2(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("class C { 0() {} }", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0].AsClassDeclaration().Members.Nodes[0]
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "_a", text1)
}

func TestGeneratedPrivateNameForMethod(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("class C { m() {} }", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0].AsClassDeclaration().Members.Nodes[0]
	name1 := ec.Factory.NewGeneratedPrivateNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "#m_1", text1)
}

func TestGeneratedNameForComputedPropertyName(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("class C { [x] }", false /*jsx*/)
	binder.BindSourceFile(file)

	n := file.Statements.Nodes[0].AsClassDeclaration().Members.Nodes[0].Name()
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "_a", text1)
}

func TestGeneratedNameForOther(t *testing.T) {
	t.Parallel()

	ec := printer.NewEmitContext()

	file := parsetestutil.ParseTypeScript("class C { [x] }", false /*jsx*/)
	binder.BindSourceFile(file)

	n := ec.Factory.NewObjectLiteralExpression(
		ec.Factory.NewNodeList([]*ast.Node{}),
		false, /*multiLine*/
	)
	name1 := ec.Factory.NewGeneratedNameForNode(n)

	g := &printer.NameGenerator{Context: ec, GetTextOfNode: (*ast.Node).Text}
	text1 := g.GenerateName(name1)

	assert.Equal(t, "_a", text1)
}