// Copyright 2015 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 transcoder

import (
	"fmt"
	"strings"
	"unicode"
	"unicode/utf8"

	"mojo/public/interfaces/bindings/mojom_types"

	"v.io/v23/vdl"
)

// upperCamelCase converts thisString to ThisString.
func upperCamelCase(s string) string {
	if s == "" {
		return ""
	}
	r, n := utf8.DecodeRuneInString(s)
	return string(unicode.ToUpper(r)) + s[n:]
}

func MojomStructToVDLType(ms mojom_types.MojomStruct, mp map[string]mojom_types.UserDefinedType) (*vdl.Type, error) {
	builder := &vdl.TypeBuilder{}
	// Note: The type key is "" below because if there is a cycle, it will have a separate reference under a separate
	// type key and if there isn't the key is irrelevant.
	pending := mojomStructToVDLType("", ms, mp, builder, map[string]vdl.TypeOrPending{})
	builder.Build()
	return pending.Built()
}

func MojomToVDLType(mt mojom_types.Type, mp map[string]mojom_types.UserDefinedType) (*vdl.Type, error) {
	builder := &vdl.TypeBuilder{}
	t := mojomToVDLType(mt, mp, builder, map[string]vdl.TypeOrPending{})
	builder.Build()
	if vt, ok := t.(*vdl.Type); ok {
		return vt, nil
	}
	return t.(vdl.PendingType).Built()

}

func mojomStructToVDLType(typeKey string, ms mojom_types.MojomStruct, mp map[string]mojom_types.UserDefinedType, builder *vdl.TypeBuilder, pendingUdts map[string]vdl.TypeOrPending) (vt vdl.PendingType) {
	strct := builder.Struct()
	if ms.DeclData.FullIdentifier != nil {
		vt = builder.Named(mojomToVdlPath(*ms.DeclData.FullIdentifier)).AssignBase(strct)
	} else {
		vt = strct
	}
	pendingUdts[typeKey] = vt
	for _, mfield := range ms.Fields {
		strct.AppendField(upperCamelCase(*mfield.DeclData.ShortName), mojomToVDLType(mfield.Type, mp, builder, pendingUdts))
	}
	return
}

func mojomToVDLTypeUDT(typeKey string, udt mojom_types.UserDefinedType, mp map[string]mojom_types.UserDefinedType, builder *vdl.TypeBuilder, pendingUdts map[string]vdl.TypeOrPending) (vt vdl.TypeOrPending) {
	u := interface{}(udt)
	switch u := u.(type) { // To do the type switch, udt has to be converted to interface{}.
	case *mojom_types.UserDefinedTypeEnumType: // enum
		me := u.Value

		// TODO: Assumes that the maximum enum index is len(me.Values) - 1.
		labels := make([]string, len(me.Values))
		for _, ev := range me.Values { // per EnumValue...
			// EnumValue has DeclData, EnumTypeKey, and IntValue.
			// We just need the first and last.
			labels[int(ev.IntValue)] = upperCamelCase(*ev.DeclData.ShortName)
		}

		vt = vdl.NamedType(mojomToVdlPath(*me.DeclData.FullIdentifier), vdl.EnumType(labels...))
		pendingUdts[typeKey] = vt
	case *mojom_types.UserDefinedTypeStructType: // struct
		vt = mojomStructToVDLType(typeKey, u.Value, mp, builder, pendingUdts)
	case *mojom_types.UserDefinedTypeUnionType: // union
		mu := u.Value

		union := builder.Union()
		vt = builder.Named(mojomToVdlPath(*mu.DeclData.FullIdentifier)).AssignBase(union)
		pendingUdts[typeKey] = vt
		for _, mfield := range mu.Fields {
			union = union.AppendField(upperCamelCase(*mfield.DeclData.ShortName), mojomToVDLType(mfield.Type, mp, builder, pendingUdts))
		}
	case *mojom_types.UserDefinedTypeInterfaceType: // interface
		panic("interfaces don't exist in vdl")
	default: // unknown
		panic(fmt.Errorf("user defined type %#v with unknown tag %d", udt, udt.Tag()))
	}
	return vt
}

// Given a mojom Type and the descriptor mapping, produce the corresponding vdltype.
func mojomToVDLType(mojomtype mojom_types.Type, mp map[string]mojom_types.UserDefinedType, builder *vdl.TypeBuilder, pendingUdts map[string]vdl.TypeOrPending) (vt vdl.TypeOrPending) {
	mt := interface{}(mojomtype)
	switch mt := interface{}(mt).(type) { // To do the type switch, mt has to be converted to interface{}.
	case *mojom_types.TypeSimpleType: // TypeSimpleType
		switch mt.Value {
		case mojom_types.SimpleType_Bool:
			vt = vdl.BoolType
		case mojom_types.SimpleType_Double:
			vt = vdl.Float64Type
		case mojom_types.SimpleType_Float:
			vt = vdl.Float32Type
		case mojom_types.SimpleType_Int8:
			vt = vdl.Int8Type
		case mojom_types.SimpleType_Int16:
			vt = vdl.Int16Type
		case mojom_types.SimpleType_Int32:
			vt = vdl.Int32Type
		case mojom_types.SimpleType_Int64:
			vt = vdl.Int64Type
		case mojom_types.SimpleType_Uint8:
			vt = vdl.ByteType
		case mojom_types.SimpleType_Uint16:
			vt = vdl.Uint16Type
		case mojom_types.SimpleType_Uint32:
			vt = vdl.Uint32Type
		case mojom_types.SimpleType_Uint64:
			vt = vdl.Uint64Type
		}
	case *mojom_types.TypeStringType: // TypeStringType
		st := mt.Value
		if st.Nullable {
			panic("nullable strings don't exist in vdl")
		}
		vt = vdl.StringType
	case *mojom_types.TypeArrayType: // TypeArrayType
		at := mt.Value
		if at.Nullable {
			panic("nullable arrays don't exist in vdl")
		}
		if at.FixedLength > 0 {
			vt = builder.Array().
				AssignLen(int(at.FixedLength)).
				AssignElem(mojomToVDLType(at.ElementType, mp, builder, pendingUdts))
		} else {
			vt = builder.List().
				AssignElem(mojomToVDLType(at.ElementType, mp, builder, pendingUdts))
		}
	case *mojom_types.TypeMapType: // TypeMapType
		// Note that mojom doesn't have sets.
		m := mt.Value
		if m.Nullable {
			panic("nullable maps don't exist in vdl")
		}
		vt = builder.Map().
			AssignKey(mojomToVDLType(m.KeyType, mp, builder, pendingUdts)).
			AssignElem(mojomToVDLType(m.ValueType, mp, builder, pendingUdts))
	case *mojom_types.TypeHandleType: // TypeHandleType
		panic("handles don't exist in vdl")
	case *mojom_types.TypeTypeReference: // TypeTypeReference
		tr := mt.Value
		if tr.IsInterfaceRequest {
			panic("interface requests don't exist in vdl")
		}
		udt := mp[*tr.TypeKey]
		var ok bool
		vt, ok = pendingUdts[*tr.TypeKey]
		if !ok {
			vt = mojomToVDLTypeUDT(*tr.TypeKey, udt, mp, builder, pendingUdts)
		}
		if tr.Nullable {
			if udt.Tag() != 1 {
				panic("nullable non-struct type reference cannot be represented in vdl")
			}
			vt = builder.Optional().AssignElem(vt)
		}
	default:
		panic(fmt.Errorf("%#v has unknown tag %d", mojomtype, mojomtype.Tag()))
	}

	return vt
}

func VDLToMojomType(t *vdl.Type) (mojomtype mojom_types.Type, mp map[string]mojom_types.UserDefinedType) {
	mp = map[string]mojom_types.UserDefinedType{}
	mojomtype = vdlToMojomTypeInternal(t, true, false, mp)
	return
}

func vdlToMojomTypeInternal(t *vdl.Type, outermostType bool, nullable bool, mp map[string]mojom_types.UserDefinedType) (mojomtype mojom_types.Type) {
	switch t.Kind() {
	case vdl.Bool, vdl.Float64, vdl.Float32, vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64, vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64:
		return &mojom_types.TypeSimpleType{
			simpleTypeCode(t.Kind()),
		}
	case vdl.String:
		return &mojom_types.TypeStringType{
			stringType(nullable),
		}
	case vdl.Array:
		elem := vdlToMojomTypeInternal(t.Elem(), false, false, mp)
		return &mojom_types.TypeArrayType{
			arrayType(elem, nullable, t.Len()),
		}
	case vdl.List:
		elem := vdlToMojomTypeInternal(t.Elem(), false, false, mp)
		return &mojom_types.TypeArrayType{
			listType(elem, nullable),
		}
	case vdl.Map:
		key := vdlToMojomTypeInternal(t.Key(), false, false, mp)
		elem := vdlToMojomTypeInternal(t.Elem(), false, false, mp)
		return &mojom_types.TypeMapType{
			mapType(key, elem, nullable),
		}
	case vdl.Struct, vdl.Union, vdl.Enum:
		udtKey := addUserDefinedType(t, mp)
		ret := &mojom_types.TypeTypeReference{
			mojom_types.TypeReference{
				Nullable: nullable,
				TypeKey:  &udtKey,
			},
		}
		if !outermostType {
			// This is needed to match the output of the generator exactly, the outermost type
			// is not given an identifier.
			ret.Value.Identifier = ret.Value.TypeKey
		}
		return ret
	case vdl.Optional:
		return vdlToMojomTypeInternal(t.Elem(), false, true, mp)
	default:
		panic(fmt.Sprintf("conversion from VDL kind %v to mojom type not implemented", t.Kind()))
	}
}

func addUserDefinedType(t *vdl.Type, mp map[string]mojom_types.UserDefinedType) string {
	key := mojomTypeKey(t)
	if _, ok := mp[key]; ok {
		return key
	}
	mp[key] = nil // placeholder to stop recursion

	var udt mojom_types.UserDefinedType
	switch t.Kind() {
	case vdl.Struct:
		udt = structType(t, mp)
	case vdl.Union:
		udt = unionType(t, mp)
	case vdl.Enum:
		udt = enumType(t)
	default:
		panic(fmt.Sprintf("conversion from VDL kind %v to mojom user defined type not implemented", t.Kind()))
	}

	mp[key] = udt
	return key
}

func simpleTypeCode(k vdl.Kind) mojom_types.SimpleType {
	switch k {
	case vdl.Bool:
		return mojom_types.SimpleType_Bool
	case vdl.Float64:
		return mojom_types.SimpleType_Double
	case vdl.Float32:
		return mojom_types.SimpleType_Float
	case vdl.Int8:
		return mojom_types.SimpleType_Int8
	case vdl.Int16:
		return mojom_types.SimpleType_Int16
	case vdl.Int32:
		return mojom_types.SimpleType_Int32
	case vdl.Int64:
		return mojom_types.SimpleType_Int64
	case vdl.Byte:
		return mojom_types.SimpleType_Uint8
	case vdl.Uint16:
		return mojom_types.SimpleType_Uint16
	case vdl.Uint32:
		return mojom_types.SimpleType_Uint32
	case vdl.Uint64:
		return mojom_types.SimpleType_Uint64
	default:
		panic(fmt.Sprintf("kind %v does not represent a simple type", k))
	}
}

func stringType(nullable bool) mojom_types.StringType {
	return mojom_types.StringType{nullable}
}

func arrayType(elem mojom_types.Type, nullable bool, length int) mojom_types.ArrayType {
	return mojom_types.ArrayType{nullable, int32(length), elem}
}

func listType(elem mojom_types.Type, nullable bool) mojom_types.ArrayType {
	return mojom_types.ArrayType{nullable, -1, elem}
}

func mapType(key, value mojom_types.Type, nullable bool) mojom_types.MapType {
	return mojom_types.MapType{nullable, key, value}
}

func structType(t *vdl.Type, mp map[string]mojom_types.UserDefinedType) mojom_types.UserDefinedType {
	structFields := make([]mojom_types.StructField, t.NumField())
	for i := 0; i < t.NumField(); i++ {
		structFields[i] = mojom_types.StructField{
			DeclData: &mojom_types.DeclarationData{ShortName: strPtr(t.Field(i).Name)},
			Type:     vdlToMojomTypeInternal(t.Field(i).Type, false, false, mp),
			Offset:   0, // Despite the fact that we can calculated the offset, set it to zero to match the generator
		}
	}
	_, name := vdl.SplitIdent(t.Name())
	return &mojom_types.UserDefinedTypeStructType{
		mojom_types.MojomStruct{
			DeclData: &mojom_types.DeclarationData{
				ShortName:      strPtr(name),
				FullIdentifier: strPtr(mojomIdentifier(t)),
			},
			Fields: structFields,
		},
	}
}

func unionType(t *vdl.Type, mp map[string]mojom_types.UserDefinedType) mojom_types.UserDefinedType {
	unionFields := make([]mojom_types.UnionField, t.NumField())
	for i := 0; i < t.NumField(); i++ {
		unionFields[i] = mojom_types.UnionField{
			DeclData: &mojom_types.DeclarationData{ShortName: strPtr(t.Field(i).Name)},
			Type:     vdlToMojomTypeInternal(t.Field(i).Type, false, false, mp),
			Tag:      uint32(i),
		}
	}
	_, name := vdl.SplitIdent(t.Name())
	return &mojom_types.UserDefinedTypeUnionType{
		mojom_types.MojomUnion{
			DeclData: &mojom_types.DeclarationData{
				ShortName:      strPtr(name),
				FullIdentifier: strPtr(mojomIdentifier(t)),
			},
			Fields: unionFields,
		},
	}
}

func enumType(t *vdl.Type) mojom_types.UserDefinedType {
	enumValues := make([]mojom_types.EnumValue, t.NumEnumLabel())
	for i := 0; i < t.NumEnumLabel(); i++ {
		enumValues[i] = mojom_types.EnumValue{
			DeclData: &mojom_types.DeclarationData{ShortName: strPtr(t.EnumLabel(i))},
			IntValue: int32(i),
		}
	}
	_, name := vdl.SplitIdent(t.Name())
	return &mojom_types.UserDefinedTypeEnumType{
		mojom_types.MojomEnum{
			DeclData: &mojom_types.DeclarationData{
				ShortName:      strPtr(name),
				FullIdentifier: strPtr(mojomIdentifier(t)),
			},
			Values: enumValues,
		},
	}
}

func strPtr(x string) *string {
	return &x
}

// mojomTypeKey creates a key from the vdl type's name that matches the generator's key.
// The reason for exactly matching the generator is to simplify the tests.
func mojomTypeKey(t *vdl.Type) string {
	return fmt.Sprintf("TYPE_KEY:%s", mojomIdentifier(t))
}

func mojomIdentifier(t *vdl.Type) string {
	return strings.Replace(t.Name(), "/", ".", -1)
}

// "a.b.c.D" -> "a/b/c.D"
func mojomToVdlPath(path string) string {
	lastDot := strings.LastIndex(path, ".")
	if lastDot == -1 {
		return path
	}
	return strings.Replace(path[:lastDot], ".", "/", -1) + path[lastDot:]
}