// Copyright 2021 The Fuchsia 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 fidlgen_cpp

import (
	"fmt"
	"strings"
	"text/template"
)

// Helper functions used by templates.

// ensureNamespace changes the current namespace to the one supplied and
// returns the C++ code required to switch to that namespace.
func ensureNamespace(arg interface{}) string {
	lines := []string{}

	newNamespace := []string{}
	switch v := arg.(type) {
	case namespaced:
		newNamespace = []string(v.Namespace())
	case string:
		newNamespace = strings.Split(v, "::")
		for len(newNamespace) > 0 && newNamespace[0] == "" {
			newNamespace = newNamespace[1:]
		}
	default:
		panic(fmt.Sprintf("Unexpected %T argument to EnsureNamespace", arg))
	}

	// Copy the namespaces
	new := make([]string, len(newNamespace))
	copy(new, newNamespace)
	current := make([]string, len(currentNamespace))
	copy(current, currentNamespace)

	// Remove common prefix
	for len(new) > 0 && len(current) > 0 && new[0] == current[0] {
		new = new[1:]
		current = current[1:]
	}

	// Leave the current namespace
	for i := len(current) - 1; i >= 0; i-- {
		lines = append(lines, fmt.Sprintf("}  // namespace %s", current[i]))
	}

	// Enter thew new namespace
	for i := 0; i < len(new); i++ {
		lines = append(lines, fmt.Sprintf("namespace %s {", new[i]))
	}

	// Update the current namespace variable
	currentNamespace = namespace(newNamespace)

	return strings.Join(lines, "\n")
}

// During template processing this holds the stack of namespaces.
// When a template calls IfdefFuchsia the current namespace is pushed onto the
// stack. When a template calls EndifFuchsia a namespace is popped off the
// stack and C++ code needed to go from the current namespace to the popped
// namespace is generated.
// This allows templates to maintain a consistent C++ namespace as they enter
// and leave #ifdef __Fuchsia__ blocks.
var namespaceStack = []namespace{}

func ifdefFuchsia() string {
	namespaceStack = append(namespaceStack, currentNamespace)

	if len(namespaceStack) == 1 {
		return "\n#ifdef __Fuchsia__\n"
	}
	return ""
}

func endifFuchsia() string {
	last := len(namespaceStack) - 1
	ns := namespaceStack[last]
	namespaceStack = namespaceStack[:last]
	s := ensureNamespace(ns)
	if len(namespaceStack) == 0 {
		return s + "\n#endif  // __Fuchsia__\n"
	}
	return s
}

func endOfFile() string {
	if len(namespaceStack) != 0 {
		panic("The namespace stack isn't empty, there's a EndifFuchsia missing somewhere")
	}
	return ensureNamespace("::")
}

// CommonTemplateFuncs holds a template.FuncMap containing common funcs.
var CommonTemplateFuncs = template.FuncMap{
	"Eq":  func(a interface{}, b interface{}) bool { return a == b },
	"NEq": func(a interface{}, b interface{}) bool { return a != b },

	"Kinds":       func() interface{} { return Kinds },
	"FamilyKinds": func() interface{} { return FamilyKinds },
	"TypeKinds":   func() interface{} { return TypeKinds },

	"IfdefFuchsia":    ifdefFuchsia,
	"EndifFuchsia":    endifFuchsia,
	"EnsureNamespace": ensureNamespace,
	"EndOfFile":       endOfFile,

	// UseNatural sets the template engine to default to the "natural" domain object
	// namespace, when printing nameVariants.
	//
	// Example of Natural type name: "fuchsia::library::MyType".
	"UseNatural": func() string {
		currentVariant = naturalVariant
		return ""
	},

	// UseUnified sets the template engine to default to the "unified" domain object
	// namespace, when printing nameVariants.
	//
	// Example of Unified type name: "fuchsia_library::MyType".
	"UseUnified": func() string {
		currentVariant = unifiedVariant
		return ""
	},

	// UseWire sets the template engine to default to the "wire" domain object
	// namespace, when printing nameVariants.
	//
	// Example of Wire type name: "fuchsia_library::wire::MyType".
	"UseWire": func() string {
		currentVariant = wireVariant
		return ""
	},
}

func MergeFuncMaps(all ...template.FuncMap) template.FuncMap {
	merged := template.FuncMap{}
	for _, funcs := range all {
		for k, fn := range funcs {
			merged[k] = fn
		}
	}
	return merged
}