// Copyright 2015 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package android

import (
	"reflect"
	"strconv"
	"testing"

	"github.com/google/blueprint/proptools"
)

type printfIntoPropertyTestCase struct {
	in  string
	val interface{}
	out string
	err bool
}

var printfIntoPropertyTestCases = []printfIntoPropertyTestCase{
	{
		in:  "%d",
		val: 0,
		out: "0",
	},
	{
		in:  "%d",
		val: 1,
		out: "1",
	},
	{
		in:  "%d",
		val: 2,
		out: "2",
	},
	{
		in:  "%d",
		val: false,
		out: "0",
	},
	{
		in:  "%d",
		val: true,
		out: "1",
	},
	{
		in:  "%d",
		val: -1,
		out: "-1",
	},

	{
		in:  "-DA=%d",
		val: 1,
		out: "-DA=1",
	},
	{
		in:  "-DA=%du",
		val: 1,
		out: "-DA=1u",
	},
	{
		in:  "-DA=%s",
		val: "abc",
		out: "-DA=abc",
	},
	{
		in:  `-DA="%s"`,
		val: "abc",
		out: `-DA="abc"`,
	},

	{
		in:  "%%",
		err: true,
	},
	{
		in:  "%d%s",
		err: true,
	},
	{
		in:  "%d,%s",
		err: true,
	},
	{
		in:  "%d",
		val: "",
		err: true,
	},
	{
		in:  "%d",
		val: 1.5,
		err: true,
	},
	{
		in:  "%f",
		val: 1.5,
		err: true,
	},
}

func TestPrintfIntoProperty(t *testing.T) {
	for _, testCase := range printfIntoPropertyTestCases {
		s := testCase.in
		v := reflect.ValueOf(&s).Elem()
		err := printfIntoProperty(v, testCase.val)
		if err != nil && !testCase.err {
			t.Errorf("unexpected error %s", err)
		} else if err == nil && testCase.err {
			t.Errorf("expected error")
		} else if err == nil && v.String() != testCase.out {
			t.Errorf("expected %q got %q", testCase.out, v.String())
		}
	}
}

type testProductVariableModule struct {
	ModuleBase
}

func (m *testProductVariableModule) GenerateAndroidBuildActions(ctx ModuleContext) {
}

var testProductVariableProperties = struct {
	Product_variables struct {
		Eng struct {
			Srcs   []string
			Cflags []string
		}
	}
}{}

func testProductVariableModuleFactoryFactory(props interface{}) func() Module {
	return func() Module {
		m := &testProductVariableModule{}
		clonedProps := proptools.CloneProperties(reflect.ValueOf(props)).Interface()
		m.AddProperties(clonedProps)

		// Set a default soongConfigVariableProperties, this will be used as the input to the property struct filter
		// for this test module.
		m.variableProperties = testProductVariableProperties
		InitAndroidModule(m)
		return m
	}
}

func TestProductVariables(t *testing.T) {
	// Test that a module can use one product variable even if it doesn't have all the properties
	// supported by that product variable.
	bp := `
		module1 {
			name: "foo",
			product_variables: {
				eng: {
					srcs: ["foo.c"],
				},
			},
		}
		module2 {
			name: "bar",
			product_variables: {
				eng: {
					cflags: ["-DBAR"],
				},
			},
		}

		module3 {
			name: "baz",
		}
	`

	GroupFixturePreparers(
		FixtureModifyProductVariables(func(variables FixtureProductVariables) {
			variables.Eng = proptools.BoolPtr(true)
		}),
		FixtureRegisterWithContext(func(ctx RegistrationContext) {
			// A module type that has a srcs property but not a cflags property.
			ctx.RegisterModuleType("module1", testProductVariableModuleFactoryFactory(&struct {
				Srcs []string
			}{}))
			// A module type that has a cflags property but not a srcs property.
			ctx.RegisterModuleType("module2", testProductVariableModuleFactoryFactory(&struct {
				Cflags []string
			}{}))
			// A module type that does not have any properties that match product_variables.
			ctx.RegisterModuleType("module3", testProductVariableModuleFactoryFactory(&struct {
				Foo []string
			}{}))
			registerVariableBuildComponents(ctx)
		}),
		FixtureWithRootAndroidBp(bp),
	).RunTest(t)
}

var testProductVariableDefaultsProperties = struct {
	Product_variables struct {
		Eng struct {
			Foo []string `android:"arch_variant"`
			Bar []string
		} `android:"arch_variant"`
	} `android:"arch_variant"`
}{}

type productVariablesDefaultsTestProperties struct {
	Foo []string `android:"arch_variant"`
}

type productVariablesDefaultsTestProperties2 struct {
	Foo []string
	Bar []string
}

type productVariablesDefaultsTestModule struct {
	ModuleBase
	DefaultableModuleBase
	properties productVariablesDefaultsTestProperties
}

func (d *productVariablesDefaultsTestModule) GenerateAndroidBuildActions(ctx ModuleContext) {
	ctx.Build(pctx, BuildParams{
		Rule:   Touch,
		Output: PathForModuleOut(ctx, "out"),
	})
}

func productVariablesDefaultsTestModuleFactory() Module {
	module := &productVariablesDefaultsTestModule{}
	module.AddProperties(&module.properties)
	module.variableProperties = testProductVariableDefaultsProperties
	InitAndroidArchModule(module, DeviceSupported, MultilibBoth)
	InitDefaultableModule(module)
	return module
}

type productVariablesDefaultsTestDefaults struct {
	ModuleBase
	DefaultsModuleBase
}

func productVariablesDefaultsTestDefaultsFactory() Module {
	defaults := &productVariablesDefaultsTestDefaults{}
	defaults.AddProperties(&productVariablesDefaultsTestProperties{})
	defaults.AddProperties(&productVariablesDefaultsTestProperties2{})
	defaults.variableProperties = testProductVariableDefaultsProperties
	InitDefaultsModule(defaults)
	return defaults
}

// Test a defaults module that supports more product variable properties than the target module.
func TestProductVariablesDefaults(t *testing.T) {
	bp := `
		defaults {
			name: "defaults",
			product_variables: {
				eng: {
					foo: ["product_variable_defaults"],
					bar: ["product_variable_defaults"],
				},
			},
			foo: ["defaults"],
			bar: ["defaults"],
		}

		test {
			name: "foo",
			defaults: ["defaults"],
			foo: ["module"],
			product_variables: {
				eng: {
					foo: ["product_variable_module"],
				},
			},
		}
	`

	result := GroupFixturePreparers(
		FixtureModifyProductVariables(func(variables FixtureProductVariables) {
			variables.Eng = boolPtr(true)
		}),
		PrepareForTestWithDefaults,
		PrepareForTestWithVariables,
		FixtureRegisterWithContext(func(ctx RegistrationContext) {
			ctx.RegisterModuleType("test", productVariablesDefaultsTestModuleFactory)
			ctx.RegisterModuleType("defaults", productVariablesDefaultsTestDefaultsFactory)
		}),
		FixtureWithRootAndroidBp(bp),
	).RunTest(t)

	foo := result.ModuleForTests("foo", "").Module().(*productVariablesDefaultsTestModule)

	want := []string{"defaults", "module", "product_variable_defaults", "product_variable_module"}
	AssertDeepEquals(t, "foo", want, foo.properties.Foo)
}

func BenchmarkSliceToTypeArray(b *testing.B) {
	for _, n := range []int{1, 2, 4, 8, 100} {
		var propStructs []interface{}
		for i := 0; i < n; i++ {
			propStructs = append(propStructs, &struct {
				A *string
				B string
			}{})

		}
		b.Run(strconv.Itoa(n), func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				_ = sliceToTypeArray(propStructs)
			}
		})
	}
}

// Test a defaults module that supports more product variable properties than the target module.
func TestProductVariablesArch(t *testing.T) {
	bp := `
		test {
			name: "foo",
			arch: {
				arm: {
					product_variables: {
						eng: {
							foo: ["arm"],
						},
					},
				},
				arm64: {
					product_variables: {
						eng: {
							foo: ["arm64"],
						},
					},
				},
			},
			foo: ["module"],
		}
	`

	result := GroupFixturePreparers(
		FixtureModifyProductVariables(func(variables FixtureProductVariables) {
			variables.Eng = boolPtr(true)
		}),
		PrepareForTestWithArchMutator,
		PrepareForTestWithVariables,
		FixtureRegisterWithContext(func(ctx RegistrationContext) {
			ctx.RegisterModuleType("test", productVariablesDefaultsTestModuleFactory)
		}),
		FixtureWithRootAndroidBp(bp),
	).RunTest(t)

	foo := result.ModuleForTests("foo", "android_arm64_armv8-a").Module().(*productVariablesDefaultsTestModule)

	want := []string{"module", "arm64"}
	AssertDeepEquals(t, "foo", want, foo.properties.Foo)
}