package wasm

import (
	"errors"
	"fmt"
	"reflect"
	"syscall/js"
)

// ErrMultipleReturnValue is an error where a JS function is attempted to be unmarshalled into a Go function with
// multiple return values.
var ErrMultipleReturnValue = errors.New("a JS function can only return one value")

// InvalidFromJSValueError is an error where an invalid argument is passed to FromJSValue.
// The argument to Unmarshal must be a non-nil pointer.
type InvalidFromJSValueError struct {
	Type reflect.Type
}

// Error implements error.
func (e InvalidFromJSValueError) Error() string {
	return "invalid argument passed to FromJSValue. Got type " + e.Type.String()
}

// InvalidTypeError is an error where the JS value cannot be unmarshalled into the provided Go type.
type InvalidTypeError struct {
	JSType js.Type
	GoType reflect.Type
}

// Error implements error.
func (e InvalidTypeError) Error() string {
	return "invalid unmarshalling: cannot unmarshal " + e.JSType.String() + " into " + e.GoType.String()
}

// InvalidArrayError is an error where the JS's array length do not match Go's array length.
type InvalidArrayError struct {
	Expected int
	Actual   int
}

// Error implements error.
func (e InvalidArrayError) Error() string {
	return fmt.Sprintf(
		"invalid unmarshalling: expected array of length %d to match Go array but got JS array of length %d",
		e.Expected, e.Actual,
	)
}

// Decoder is an interface which manually decodes js.Value on its own.
// It overrides in FromJSValue.
type Decoder interface {
	FromJSValue(js.Value) error
}

// FromJSValue converts a given js.Value to the Go equivalent.
// The new value of 'out' is undefined if FromJSValue returns an error.
//
// When a JS function is unmarshalled into a Go function with only one return value, the returned JS value is casted
// into the type of the return value. If the conversion fails, the function call panics.
//
// When a JS function is unmarshalled into a Go function with two return values, the second one being error, the
// conversion error is returned instead.
func FromJSValue(x js.Value, out interface{}) error {
	v := reflect.ValueOf(out)
	if v.Kind() != reflect.Ptr || v.IsNil() {
		return &InvalidFromJSValueError{reflect.TypeOf(v)}
	}

	return decodeValue(x, v.Elem())
}

// decodeValue decodes the provided js.Value into the provided reflect.Value.
func decodeValue(x js.Value, v reflect.Value) error {
	// If we have undefined or null, we need to be able to set to the pointer itself.
	// All code beyond this point are pointer-unaware so we handle undefined or null first.
	if x.Type() == js.TypeUndefined || x.Type() == js.TypeNull {
		return decodeNothing(v)
	}

	// Implementations of Decoder are probably on pointer so do it before pointer code.
	if d, ok := v.Addr().Interface().(Decoder); ok {
		return d.FromJSValue(x)
	}

	// Make sure everything is initialized and indirect it.
	// This prevents other decode functions from having to handle pointers.
	if v.Kind() == reflect.Ptr {
		initializePointerIfNil(v)
		v = reflect.Indirect(v)
	}

	if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
		// It's a interface{} so we just create the easiest Go representation we can in createInterface.
		res := createInterface(x)
		if res != nil {
			v.Set(reflect.ValueOf(res))
		}
		return nil
	}

	// Directly set v if it's a js.Value.
	if _, ok := v.Interface().(js.Value); ok {
		v.Set(reflect.ValueOf(x))
		return nil
	}

	// Go the reflection route.
	switch x.Type() {
	case js.TypeBoolean:
		return decodeBoolean(x, v)
	case js.TypeNumber:
		return decodeNumber(x, v)
	case js.TypeString:
		return decodeString(x, v)
	case js.TypeSymbol:
		return decodeSymbol(x, v)
	case js.TypeObject:
		if isArray(x) {
			return decodeArray(x, v)
		}
		return decodeObject(x, v)
	case js.TypeFunction:
		return decodeFunction(x, v)
	default:
		panic("unknown JS type: " + x.Type().String())
	}
}

// decodeNothing decodes an undefined or a null into the provided reflect.Value.
func decodeNothing(v reflect.Value) error {
	if v.Kind() != reflect.Ptr {
		return InvalidTypeError{js.TypeNull, v.Type()}
	}
	v.Set(reflect.ValueOf(nil))
	return nil
}

// decodeBoolean decodes a bool into the provided reflect.Value.
func decodeBoolean(x js.Value, v reflect.Value) error {
	if v.Kind() != reflect.Bool {
		return InvalidTypeError{js.TypeBoolean, v.Type()}
	}
	v.SetBool(x.Bool())
	return nil
}

// decodeNumber decodes a JS number into the provided reflect.Value, truncating as necessary.
func decodeNumber(x js.Value, v reflect.Value) error {
	switch v.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		v.SetInt(int64(x.Float()))
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		v.SetUint(uint64(x.Float()))
	case reflect.Float32, reflect.Float64:
		v.SetFloat(x.Float())
	default:
		return InvalidTypeError{js.TypeNumber, v.Type()}
	}
	return nil
}

// decodeString decodes a JS string into the provided reflect.Value.
func decodeString(x js.Value, v reflect.Value) error {
	if v.Kind() != reflect.String {
		return InvalidTypeError{js.TypeString, v.Type()}
	}
	v.SetString(x.String())
	return nil
}

// decodeSymbol decodes a JS symbol into the provided reflect.Value.
func decodeSymbol(x js.Value, v reflect.Value) error {
	// TODO Decode it into a symbol type.
	return InvalidTypeError{js.TypeSymbol, v.Type()}
}

// decodeArray decodes a JS array into the provided reflect.Value.
func decodeArray(x js.Value, v reflect.Value) error {
	jsLen := x.Length()

	switch v.Kind() {
	case reflect.Array:
		if jsLen != v.Len() {
			return InvalidArrayError{v.Len(), jsLen}
		}
	case reflect.Slice:
		newSlice := reflect.MakeSlice(v.Type(), jsLen, jsLen)
		v.Set(newSlice)
	default:
		return InvalidTypeError{js.TypeObject, v.Type()}
	}

	for i := 0; i < jsLen; i++ {
		err := FromJSValue(x.Index(i), v.Index(i).Addr().Interface())
		if err != nil {
			return err
		}
	}
	return nil
}

// decodeObject decodes a JS object into the provided reflect.Value.
func decodeObject(x js.Value, v reflect.Value) error {
	switch v.Kind() {
	case reflect.Struct:
		return decodeObjectIntoStruct(x, v)
	case reflect.Map:
		return decodeObjectIntoMap(x, v)
	default:
		return InvalidTypeError{js.TypeObject, v.Type()}
	}
}

// decodeObject decodes a JS object into the provided reflect.Value struct.
func decodeObjectIntoStruct(x js.Value, v reflect.Value) error {
	for i := 0; i < v.Type().NumField(); i++ {
		fieldType := v.Type().Field(i)
		if fieldType.PkgPath != "" {
			continue
		}

		name := fieldType.Name
		tagName, tagOK := fieldType.Tag.Lookup("wasm")

		if tagOK {
			name = tagName
		}

		err := decodeValue(x.Get(name), v.Field(i))
		if err != nil {
			if tagOK {
				return fmt.Errorf("in field %s (JS %s): %w", fieldType.Name, tagName, err)
			}
			return fmt.Errorf("in field %s: %w", fieldType.Name, err)
		}
	}

	return nil
}

func decodeObjectIntoMap(x js.Value, v reflect.Value) error {
	mapType := v.Type()
	keyType := mapType.Key()
	valType := mapType.Elem()

	switch keyType.Kind() {
	case reflect.String:
	case reflect.Interface:
		if keyType.NumMethod() != 0 {
			return InvalidTypeError{js.TypeObject, mapType}
		}
	default:
		return InvalidTypeError{js.TypeObject, mapType}
	}

	// TODO: Use Object API
	obj, err := Global().Get("Object")
	if err != nil {
		panic("Object not found")
	}

	var keys []string
	err = FromJSValue(obj.Call("keys", x), &keys)
	if err != nil {
		panic("Object.keys returned non-string-array.")
	}

	for _, k := range keys {
		valuePtr := reflect.New(valType).Interface()
		err := FromJSValue(x.Get(k), valuePtr)
		if err != nil {
			return err
		}

		v.SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(valuePtr).Elem())
	}
	return nil
}

// decodeFunction decodes a JS function into the provided reflect.Value.
func decodeFunction(x js.Value, v reflect.Value) error {
	funcType := v.Type()
	outCount := funcType.NumOut()

	switch outCount {
	case 0, 1:
	case 2:
		if funcType.Out(1) != errorType {
			return ErrMultipleReturnValue
		}
	default:
		return ErrMultipleReturnValue
	}

	v.Set(reflect.MakeFunc(funcType, func(args []reflect.Value) []reflect.Value {
		argsJS := make([]interface{}, 0, len(args))
		for _, v := range args {
			argsJS = append(argsJS, ToJSValue(v.Interface()))
		}

		jsReturn := x.Invoke(argsJS...)
		if outCount == 0 {
			return []reflect.Value{}
		}

		returnPtr := reflect.New(funcType.Out(0)).Interface()
		err := FromJSValue(jsReturn, returnPtr)

		returnVal := reflect.ValueOf(returnPtr).Elem()
		if err != nil {
			if outCount == 1 {
				panic("error decoding JS return value: " + err.Error())
			}

			return []reflect.Value{returnVal, reflect.ValueOf(err)}
		}

		switch outCount {
		case 1:
			return []reflect.Value{returnVal}
		case 2:
			return []reflect.Value{returnVal, reflect.ValueOf(nil)}
		default:
			panic("unexpected amount of return values")
		}
	}))
	return nil
}

// createInterface creates a representation of the provided js.Value.
func createInterface(x js.Value) interface{} {
	switch x.Type() {
	case js.TypeUndefined, js.TypeNull:
		return nil
	case js.TypeBoolean:
		return x.Bool()
	case js.TypeNumber:
		return x.Float()
	case js.TypeString:
		return x.String()
	case js.TypeSymbol:
		// We can't convert it to a Go value in a meaningful way.
		return x
	case js.TypeObject:
		if isArray(x) {
			return createArray(x)
		}
		return createObject(x)
	case js.TypeFunction:
		var a func(...interface{}) (interface{}, error)
		err := FromJSValue(x, &a)
		if err != nil {
			panic("error creating function: " + err.Error())
		}
		return a
	default:
		panic("unknown JS type: " + x.Type().String())
	}
}

// createArray creates a slice of interface representing the js.Value.
func createArray(x js.Value) interface{} {
	result := make([]interface{}, x.Length())
	for i := range result {
		result[i] = createInterface(x.Index(i))
	}
	return result
}

// createObject creates a representation of the provided JS object.
func createObject(x js.Value) interface{} {
	// TODO: Use Object API
	obj, err := Global().Get("Object")
	if err != nil {
		panic("Object not found")
	}

	var keys []string
	err = FromJSValue(obj.Call("keys", x), &keys)
	if err != nil {
		panic("Object.keys returned non-string-array.")
	}

	result := make(map[string]interface{}, len(keys))
	for _, v := range keys {
		result[v] = createInterface(x.Get(v))
	}
	return result
}

// isArray calls the JS function Array.isArray to check if the provided js.Value is an array.
func isArray(x js.Value) bool {
	arr, err := Global().Get("Array")
	if err != nil {
		panic("Array not found")
	}

	return arr.Call("isArray", x).Bool()
}

// initializePointerIfNil checks if the pointer is nil and initializes it as necessary.
func initializePointerIfNil(v reflect.Value) {
	if v.Kind() != reflect.Ptr {
		return
	}
	if v.IsNil() {
		v.Set(reflect.New(v.Type().Elem()))
	}
	initializePointerIfNil(v.Elem())
}