// Copyright 2016 The Vanadium 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 golang

import (
	"fmt"
	"path"
	"strings"

	"v.io/v23/vdl"
	"v.io/v23/vdlroot/vdltool"
	"v.io/x/ref/lib/vdl/compile"
)

// defineIsZero returns the VDLIsZero method for the def type.
func defineIsZero(data *goData, def *compile.TypeDef) string {
	g := genIsZero{goData: data}
	return g.Gen(def)
}

type genIsZero struct {
	*goData
}

func (g *genIsZero) Gen(def *compile.TypeDef) string {
	// Special-case array and struct to check each elem or field for zero.
	// Special-case union to generate methods for each concrete union struct.
	//
	// Types that have a unique Go zero value can bypass these special-cases, and
	// perform a direct comparison against that zero value.  Note that def.Type
	// always represents a wire type here, since we're generating the VDLIsZero
	// method on the wire type.
	if !isGoZeroValueUniqueWire(g.goData, def.Type) {
		switch def.Type.Kind() {
		case vdl.Array:
			return g.genArrayDef(def)
		case vdl.Struct:
			return g.genStructDef(def)
		case vdl.Union:
			return g.genUnionDef(def)
		}
	}
	return g.genDef(def)
}

func (g *genIsZero) genDef(def *compile.TypeDef) string {
	tt, arg := def.Type, namedArg{"x", false}
	expr := g.ExprWire(returnEqZero, tt, arg, "")
	return fmt.Sprintf(`
func (x %[1]s) VDLIsZero() bool {
	return %[2]s
}
`, def.Name, expr)
}

func (g *genIsZero) genArrayDef(def *compile.TypeDef) string {
	tt := def.Type
	elemArg := typedArg("elem", tt.Elem())
	expr := g.Expr(ifNeZero, tt.Elem(), elemArg, "")
	return fmt.Sprintf(`
func (x %[1]s) VDLIsZero() bool {
	for _, elem := range x {
		if %[2]s {
			return false
		}
	}
	return true
}
`, def.Name, expr)
}

func (g *genIsZero) genStructDef(def *compile.TypeDef) string {
	tt, arg := def.Type, namedArg{"x", false}
	s := fmt.Sprintf(`
func (x %[1]s) VDLIsZero() bool {`, def.Name)
	for ix := 0; ix < tt.NumField(); ix++ {
		field := tt.Field(ix)
		expr := g.Expr(ifNeZero, field.Type, arg.Field(field), field.Name)
		s += fmt.Sprintf(`
	if %[1]s {
		return false
	}`, expr)
	}
	s += `
	return true
}
`
	return s
}

func (g *genIsZero) genUnionDef(def *compile.TypeDef) string {
	// The 0th field needs a real zero check.
	tt := def.Type
	field0 := tt.Field(0)
	fieldArg := typedArg("x.Value", field0.Type)
	expr := g.Expr(returnEqZero, field0.Type, fieldArg, "")
	s := fmt.Sprintf(`
func (x %[1]s%[2]s) VDLIsZero() bool {
	return %[3]s
}
`, def.Name, field0.Name, expr)
	// All other fields simply return false.
	for ix := 1; ix < tt.NumField(); ix++ {
		s += fmt.Sprintf(`
func (x %[1]s%[2]s) VDLIsZero() bool {
	return false
}
`, def.Name, tt.Field(ix).Name)
	}
	return s
}

// zeroExpr configures what type of zero expression to generate.
type zeroExpr int

const (
	ifEqZero     = iota // Generate expression for "if x == 0 {" statement
	ifNeZero            // Generate expression for "if x != 0 {" statement
	returnEqZero        // Generate expression for "return x == 0" statement
)

func (ze zeroExpr) GenEqual() bool {
	return ze == ifEqZero || ze == returnEqZero
}
func (ze zeroExpr) GenNotEqual() bool {
	return !ze.GenEqual()
}
func (ze zeroExpr) GenIfStmt() bool {
	return ze == ifEqZero || ze == ifNeZero
}
func (ze zeroExpr) GenReturnStmt() bool {
	return !ze.GenIfStmt()
}

// Expr generates the Go code to check whether the arg, which has type tt, is
// equal or not-equal to zero.  The tmp string is appended to temporary variable
// names to make them unique.
//
// The returned expression is a boolean Go expression that evaluates whether arg
// is zero or non-zero.  It is meant to be used like this:
//     if <expr> {
//       ...
//     }
// Or like this:
//     return <expr>
//
// The first argument ze describes whether the expression will be used in an
// "if" or "return" statement, and whether it should evaluate to equal or
// not-equal to zero.  The kind of statement affects the expression because of
// Go's parsing and type safety rules.
func (g *genIsZero) Expr(ze zeroExpr, tt *vdl.Type, arg namedArg, tmp string) string {
	if native, wirePkg, ok := findNativeType(g.Env, tt); ok {
		opNot, eq, ref := "", "==", arg.Ref()
		if ze.GenNotEqual() {
			opNot, eq = "!", "!="
		}
		switch {
		case native.Zero.Mode == vdltool.GoZeroModeUnique:
			// We use an untyped const as the zero value, because Go only allows
			// comparison of slices with nil.  E.g.
			//   type MySlice []string
			//   pass := MySlice(nil) == nil          // valid
			//   fail := MySlice(nil) == MySlice(nil) // invalid
			nType := nativeType(g.goData, native, wirePkg)
			zeroValue := untypedConstNativeZero(native.Kind, nType)
			if ze.GenIfStmt() {
				if k := native.Kind; k == vdltool.GoKindStruct || k == vdltool.GoKindArray {
					// Without a special-case, we'll get a statement like:
					//   if x == Foo{} {
					// But that isn't valid Go code, so we change it to:
					//   if x == (Foo{}) {
					zeroValue = "(" + zeroValue + ")"
				}
			}
			return ref + eq + zeroValue
		case strings.HasPrefix(native.Zero.IsZero, "."):
			return opNot + arg.Name + native.Zero.IsZero
		case native.Zero.IsZero != "":
			// TODO(toddw): Handle the function form of IsZero, including IsZeroImports.
			vdlconfig := path.Join(wirePkg.GenPath, "vdl.config")
			g.Env.Errors.Errorf("%s: native type %s uses function form of IsZero, which isn't implemented", vdlconfig, native.Type)
			return ""
		}
	}
	return g.ExprWire(ze, tt, arg, tmp)
}

// ExprWire is like Expr, but generates code for the wire type tt.
func (g *genIsZero) ExprWire(ze zeroExpr, tt *vdl.Type, arg namedArg, tmp string) string {
	opNot, eq, cond, ref := "", "==", "||", arg.Ref()
	if ze.GenNotEqual() {
		opNot, eq, cond = "!", "!=", "&&"
	}
	// Handle everything other than Array and Struct.
	switch tt.Kind() {
	case vdl.Bool:
		expr := "!" + ref // false is zero, while true is non-zero
		if ze.GenNotEqual() {
			expr = ref
		}
		if ze.GenReturnStmt() && tt.Name() != "" {
			// Special-case named bool types, since we'll get an expression like "x",
			// but we need an explicit conversion since the type of x is the named
			// bool type, not the built-in bool type.
			expr = "bool(" + expr + ")"
		}
		return expr
	case vdl.String:
		return ref + eq + `""`
	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64, vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64, vdl.Float32, vdl.Float64:
		return ref + eq + "0"
	case vdl.Enum:
		return ref + eq + typeGoWire(g.goData, tt) + tt.EnumLabel(0)
	case vdl.TypeObject:
		return ref + eq + "nil" + cond + ref + eq + g.Pkg("v.io/v23/vdl") + "AnyType"
	case vdl.List, vdl.Set, vdl.Map:
		return "len(" + ref + ")" + eq + "0"
	case vdl.Optional:
		return arg.Name + eq + "nil"
	}
	// The interface{} representation of any is special-cased, since it behaves
	// differently than the *vdl.Value and *vom.RawBytes representations.
	if tt.Kind() == vdl.Any && goAnyRepMode(g.Package) == goAnyRepInterface {
		return ref + eq + "nil"
	}
	switch tt.Kind() {
	case vdl.Union, vdl.Any:
		// Union is always named, and Any is either *vdl.Value or *vom.RawBytes, so
		// we call VDLIsZero directly.  A slight complication is the fact that all
		// of these might be nil, which we need to protect against before making the
		// VDLIsZero call.
		return ref + eq + "nil" + cond + opNot + arg.Name + ".VDLIsZero()"
	}
	// Only Array and Struct are left.
	//
	// If there is a unique Go zero value, we generate a fastpath that simply
	// compares against that value.  Note that tt always represents a wire type
	// here, since native types were handled in Expr.
	if isGoZeroValueUniqueWire(g.goData, tt) {
		zeroValue := typedConstWire(g.goData, vdl.ZeroValue(tt))
		if ze.GenIfStmt() {
			// Without a special-case, we'll get a statement like:
			//   if x == Foo{} {
			// But that isn't valid Go code, so we change it to:
			//   if x == (Foo{}) {
			zeroValue = "(" + zeroValue + ")"
		}
		return ref + eq + zeroValue
	}
	// Otherwise we call VDLIsZero directly.  This takes advantage of the fact
	// that Array and Struct are always named, so will always have a VDLIsZero
	// method defined.
	return opNot + arg.Name + ".VDLIsZero()"
}

// isGoZeroValueUniqueWire returns true iff the Go zero value of the wire type
// tt represents the VDL zero value, and is the *only* value that represents the
// VDL zero value.
func isGoZeroValueUniqueWire(data *goData, tt *vdl.Type) bool {
	// Not unique if tt contains inline native subtypes that don't have a unique
	// zero representation.  This doesn't apply if tt itself is native, but has no
	// inline native subtypes, since this function only considers the wire type
	// form of tt.
	if containsInlineNativeNonUniqueSubTypes(data, tt, true) {
		return false
	}
	// Not unique if tt contains types where there is more than one VDL zero value
	// representation:
	//   Any:            nil, or VDLIsZero on vdl.Value/vom.RawBytes
	//   TypeObject:     nil, or AnyType
	//   Union:          nil, or zero value of field 0
	//   List, Set, Map: nil, or empty
	//
	// Note that the interface{} representation of Any uses nil as the only VDL
	// zero value, while the vdl.Value/vom.RawBytes pointers can either be nil, or
	// represent VDL zero through their non-nil pointer.
	kkNotUnique := []vdl.Kind{vdl.TypeObject, vdl.Union, vdl.List, vdl.Set, vdl.Map}
	if goAnyRepMode(data.Package) != goAnyRepInterface {
		kkNotUnique = append(kkNotUnique, vdl.Any)
	}
	if tt.ContainsKind(vdl.WalkInline, kkNotUnique...) {
		return false
	}
	return true
}

// isGoZeroValueCanonical returns true iff the Go zero value of the type tt
// (which may be a native type) is the canonical representation of the VDL zero
// value.  This differs from isGoZeroValueUniqueWire since e.g. the canonical
// zero value of list is nil, which is the Go zero value, but it isn't unique
// since it isn't the only zero value representation.  Also this checks if tt is
// a native type, while isGoZeroValueUniqueWire assumes tt is a wire type.
func isGoZeroValueCanonical(data *goData, tt *vdl.Type) bool {
	// If tt is a native type in either Canonical or Unique zero mode, the Go zero
	// value is canonical.  Note that Unique zero mode is stronger than Canonical;
	// not only is the Go zero value canonical, it's the only representation.
	if native, _, ok := findNativeType(data.Env, tt); ok {
		if native.Zero.Mode != vdltool.GoZeroModeUnknown {
			return true
		}
	}
	// Not canonical if tt contains inline native subtypes that don't have a
	// Canonical or Unique zero mode.
	if containsInlineNativeUnknownSubTypes(data, tt, false) {
		return false
	}
	// Not canonical if tt contains types where the Go zero value isn't the
	// canonical VDL zero value.
	//
	// Note that The interface{} representation of Any uses nil as the only VDL
	// zero value, while the vdl.Value/vom.RawBytes pointers use a non-nil pointer
	// as the canonical VDL zero value.
	kkNotCanonical := []vdl.Kind{vdl.TypeObject, vdl.Union}
	if goAnyRepMode(data.Package) != goAnyRepInterface {
		kkNotCanonical = append(kkNotCanonical, vdl.Any)
	}
	if tt.ContainsKind(vdl.WalkInline, kkNotCanonical...) {
		return false
	}
	return true
}

func containsInlineNativeNonUniqueSubTypes(data *goData, tt *vdl.Type, wireOnly bool) bool {
	// The walk early-exits if the visitor functor returns false.  We want the
	// early-exit when we detect the first native type, so we use false to mean
	// that we've seen a native type, and true if we haven't.
	return !tt.Walk(vdl.WalkInline, func(visit *vdl.Type) bool {
		if wireOnly && visit == tt {
			// We don't want the native check to fire for tt itself, so we return true
			// when we visit tt, meaning we haven't detected a native type yet.
			return true
		}
		if native, _, ok := findNativeType(data.Env, visit); ok {
			return native.Zero.Mode == vdltool.GoZeroModeUnique
		}
		return true
	})
}

func containsInlineNativeUnknownSubTypes(data *goData, tt *vdl.Type, wireOnly bool) bool {
	// The walk early-exits if the visitor functor returns false.  We want the
	// early-exit when we detect the first native type, so we use false to mean
	// that we've seen a native type, and true if we haven't.
	return !tt.Walk(vdl.WalkInline, func(visit *vdl.Type) bool {
		if wireOnly && visit == tt {
			// We don't want the native check to fire for tt itself, so we return true
			// when we visit tt, meaning we haven't detected a native type yet.
			return true
		}
		if native, _, ok := findNativeType(data.Env, visit); ok {
			return native.Zero.Mode != vdltool.GoZeroModeUnknown
		}
		return true
	})
}

func findNativeType(env *compile.Env, tt *vdl.Type) (vdltool.GoType, *compile.Package, bool) {
	if def := env.FindTypeDef(tt); def != nil {
		pkg := def.File.Package
		key := def.Name
		if tt.Kind() == vdl.Optional {
			key = "*" + key
		}
		native, ok := pkg.Config.Go.WireToNativeTypes[key]
		return native, pkg, ok
	}
	return vdltool.GoType{}, nil, false
}

// isNativeType returns true iff t is a native type.
func isNativeType(env *compile.Env, t *vdl.Type) bool {
	if def := env.FindTypeDef(t); def != nil {
		key := def.Name
		if t.Kind() == vdl.Optional {
			key = "*" + key
		}
		_, ok := def.File.Package.Config.Go.WireToNativeTypes[key]
		return ok
	}
	return false
}