// 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 llcpp

import (
	"fmt"
	"strconv"
	"strings"

	"go.fuchsia.dev/fuchsia/tools/fidl/gidl/lib/ir"
	"go.fuchsia.dev/fuchsia/tools/fidl/gidl/lib/mixer"
	"go.fuchsia.dev/fuchsia/tools/fidl/gidl/lib/util"
	"go.fuchsia.dev/fuchsia/tools/fidl/lib/fidlgen"
)

func BuildValueAllocator(allocatorVar string, value ir.Value, decl mixer.Declaration, handleRepr HandleRepr) (string, string) {
	var builder allocatorBuilder
	builder.allocatorVar = allocatorVar
	builder.handleRepr = handleRepr
	valueVar := builder.visit(value, decl)
	valueBuild := builder.String()
	return valueBuild, valueVar
}

type allocatorBuilder struct {
	allocatorVar string
	strings.Builder
	varidx     int
	handleRepr HandleRepr
}

func (a *allocatorBuilder) write(format string, vals ...interface{}) {
	a.WriteString(fmt.Sprintf(format, vals...))
}

func (a *allocatorBuilder) newVar() string {
	a.varidx++
	return fmt.Sprintf("var%d", a.varidx)
}

func (a *allocatorBuilder) assignNew(typename string, isPointer bool, fmtStr string, vals ...interface{}) string {
	rhs := a.construct(typename, isPointer, fmtStr, vals...)
	newVar := a.newVar()
	a.write("auto %s = %s;\n", newVar, rhs)
	return newVar
}

func (a *allocatorBuilder) construct(typename string, isPointer bool, fmtStr string, args ...interface{}) string {
	val := fmt.Sprintf(fmtStr, args...)
	if !isPointer {
		return fmt.Sprintf("%s(%s)", typename, val)
	}
	return fmt.Sprintf("fidl::ObjectView<%s>(%s, %s)", typename, a.allocatorVar, val)
}

func (a *allocatorBuilder) adoptHandle(decl mixer.Declaration, value ir.Handle) string {
	if a.handleRepr == HandleReprDisposition || a.handleRepr == HandleReprInfo {
		return fmt.Sprintf("%s(handle_defs[%d].handle)", typeName(decl), value)
	}
	return fmt.Sprintf("%s(handle_defs[%d])", typeName(decl), value)
}

func formatPrimitive(value ir.Value) string {
	switch value := value.(type) {
	case int64:
		if value == -9223372036854775808 {
			return "-9223372036854775807ll - 1"
		}
		return fmt.Sprintf("%dll", value)
	case uint64:
		return fmt.Sprintf("%dull", value)
	case float64:
		return fmt.Sprintf("%g", value)
	}
	panic("Unreachable")
}

func (a *allocatorBuilder) visit(value ir.Value, decl mixer.Declaration) string {
	// StringView and VectorView in wire types represent nullability within the object rather than as
	// as pointer to the object.
	_, isString := decl.(*mixer.StringDecl)
	_, isVector := decl.(*mixer.VectorDecl)
	isPointer := (decl.IsNullable() && !isString && !isVector)

	switch value := value.(type) {
	case bool:
		return a.construct(typeName(decl), isPointer, "%t", value)
	case int64, uint64, float64:
		switch decl := decl.(type) {
		case mixer.PrimitiveDeclaration, *mixer.EnumDecl:
			return a.construct(typeName(decl), isPointer, formatPrimitive(value))
		case *mixer.BitsDecl:
			return fmt.Sprintf("static_cast<%s>(%s)", declName(decl), formatPrimitive(value))
		}
	case ir.RawFloat:
		switch decl.(*mixer.FloatDecl).Subtype() {
		case fidlgen.Float32:
			return fmt.Sprintf("([] { uint32_t u = %#b; float f; memcpy(&f, &u, sizeof(float)); return f; })()", value)
		case fidlgen.Float64:
			return fmt.Sprintf("([] { uint64_t u = %#b; double d; memcpy(&d, &u, sizeof(double)); return d; })()", value)
		}
	case string:
		if !isPointer {
			// This clause is optional and simplifies the output.
			return strconv.Quote(value)
		}
		return a.construct(typeNameIgnoreNullable(decl), isPointer, "%q", value)
	case ir.Handle:
		switch decl := decl.(type) {
		case *mixer.HandleDecl:
			return a.adoptHandle(decl, value)
		case *mixer.ClientEndDecl:
			return fmt.Sprintf("%s(%s)", typeName(decl), a.adoptHandle(decl.UnderlyingHandleDecl(), value))
		case *mixer.ServerEndDecl:
			return fmt.Sprintf("%s(%s)", typeName(decl), a.adoptHandle(decl.UnderlyingHandleDecl(), value))
		}
	case ir.Record:
		switch decl := decl.(type) {
		case *mixer.StructDecl:
			return a.visitStruct(value, decl, isPointer)
		case *mixer.TableDecl:
			return a.visitTable(value, decl, isPointer)
		case *mixer.UnionDecl:
			return a.visitUnion(value, decl, isPointer)
		}
	case []ir.Value:
		switch decl := decl.(type) {
		case *mixer.ArrayDecl:
			return a.visitArray(value, decl, isPointer)
		case *mixer.VectorDecl:
			return a.visitVector(value, decl, isPointer)
		}
	case nil:
		return a.construct(typeName(decl), false, "")
	}
	panic(fmt.Sprintf("not implemented: %T", value))
}

func (a *allocatorBuilder) visitStruct(value ir.Record, decl *mixer.StructDecl, isPointer bool) string {
	s := a.newVar()
	structRaw := fmt.Sprintf("%s{}", typeNameIgnoreNullable(decl))
	var op string
	if isPointer {
		op = "->"
		a.write("auto %s = fidl::ObjectView<%s>(%s, %s);\n", s, typeNameIgnoreNullable(decl), a.allocatorVar, structRaw)
	} else {
		op = "."
		a.write("auto %s = %s;\n", s, structRaw)
	}

	for _, field := range value.Fields {
		fieldRhs := a.visit(field.Value, decl.Field(field.Key.Name))
		a.write("%s%s%s = %s;\n", s, op, field.Key.Name, fieldRhs)
	}

	return fmt.Sprintf("std::move(%s)", s)
}

func (a *allocatorBuilder) visitTable(value ir.Record, decl *mixer.TableDecl, isPointer bool) string {
	t := a.assignNew(declName(decl), isPointer, "%s", a.allocatorVar)
	op := "."
	if isPointer {
		op = "->"
	}

	for _, field := range value.Fields {
		if field.Key.IsUnknown() {
			panic(fmt.Sprintf("table %s: unknown ordinal %d: LLCPP cannot construct tables with unknown fields",
				decl.Name(), field.Key.UnknownOrdinal))
		}
		fieldDecl := decl.Field(field.Key.Name)
		fieldRhs := a.visit(field.Value, fieldDecl)
		if fieldDecl.IsInlinableInEnvelope() {
			a.write("%s%sset_%s(%s);\n", t, op, fidlgen.ToSnakeCase(field.Key.Name), fieldRhs)
		} else {
			a.write("%s%sset_%s(%s, %s);\n", t, op, fidlgen.ToSnakeCase(field.Key.Name), a.allocatorVar, fieldRhs)
		}
	}

	return fmt.Sprintf("std::move(%s)", t)
}

func (a *allocatorBuilder) visitUnion(value ir.Record, decl *mixer.UnionDecl, isPointer bool) string {
	s := a.newVar()
	unionRaw := a.assignNew(typeNameIgnoreNullable(decl), false, "")
	if isPointer {
		a.write("auto %s = fidl::WireOptional<%s>(std::move(%s));\n", s, typeNameIgnoreNullable(decl), unionRaw)
	} else {
		a.write("auto %s = std::move(%s);\n", s, unionRaw)
	}

	if len(value.Fields) == 1 {
		field := value.Fields[0]
		if field.Key.IsUnknown() {
			panic(fmt.Sprintf("union %s: unknown ordinal %d: LLCPP cannot construct unions with unknown fields",
				decl.Name(), field.Key.UnknownOrdinal))
		}
		fieldDecl := decl.Field(field.Key.Name)
		fieldRhs := a.visit(field.Value, fieldDecl)
		if fieldDecl.IsInlinableInEnvelope() {
			a.write("%s = %s::With%s(%s);\n", s, typeNameIgnoreNullable(decl), fidlgen.ToUpperCamelCase(field.Key.Name), fieldRhs)
		} else {
			a.write("%s = %s::With%s(%s, %s);\n", s, typeNameIgnoreNullable(decl), fidlgen.ToUpperCamelCase(field.Key.Name), a.allocatorVar, fieldRhs)
		}
	}

	return fmt.Sprintf("std::move(%s)", s)
}

func (a *allocatorBuilder) visitArray(value []ir.Value, decl *mixer.ArrayDecl, isPointer bool) string {
	array := a.assignNew(typeNameIgnoreNullable(decl), isPointer, "")
	op := ""
	if isPointer {
		op = ".get()"
	}
	for i, item := range value {
		elem := a.visit(item, decl.Elem())
		a.write("%s%s[%d] = %s;\n", array, op, i, elem)
	}
	return fmt.Sprintf("std::move(%s)", array)
}

func (a *allocatorBuilder) visitVector(value []ir.Value, decl *mixer.VectorDecl, isPointer bool) string {
	vector := a.assignNew(typeName(decl), isPointer, "%s, %d", a.allocatorVar, len(value))
	if len(value) == 0 {
		return fmt.Sprintf("std::move(%s)", vector)
	}
	// Special case unsigned integer vectors, because clang otherwise has issues with large vectors on arm.
	// This uses pattern matching so only a subset of byte vectors that fit the pattern (repeating sequence) will be optimized.
	if elemDecl, ok := decl.Elem().(mixer.PrimitiveDeclaration); ok && elemDecl.Subtype() == fidlgen.Uint8 {
		var uintValues []uint64
		for _, v := range value {
			uintValues = append(uintValues, v.(uint64))
		}
		// For simplicity, only support sizes that are multiples of the period.
		if period, ok := util.FindRepeatingPeriod(uintValues); ok && len(value)%period == 0 {
			for i := 0; i < period; i++ {
				elem := a.visit(value[i], decl.Elem())
				a.write("%s[%d] = %s;\n", vector, i, elem)
			}
			a.write(
				`for (size_t offset = 0; offset < %[1]s.size(); offset += %[2]d) {
memcpy(%[1]s.data() + offset, %[1]s.data(), %[2]d);
}
`, vector, period)
			return fmt.Sprintf("std::move(%s)", vector)
		}
		if len(uintValues) > 1024 {
			panic("large vectors that are not repeating are not supported, for build performance reasons")
		}
	}
	for i, item := range value {
		elem := a.visit(item, decl.Elem())
		a.write("%s[%d] = %s;\n", vector, i, elem)
	}
	return fmt.Sprintf("std::move(%s)", vector)
}