package vm

import (
	"bytes"
	"encoding/hex"
	"fmt"
	"reflect"

	"github.com/ipfs/go-cid"
	cbg "github.com/whyrusleeping/cbor-gen"
	"golang.org/x/xerrors"

	"github.com/filecoin-project/go-state-types/abi"
	actorstypes "github.com/filecoin-project/go-state-types/actors"
	builtinst "github.com/filecoin-project/go-state-types/builtin"
	"github.com/filecoin-project/go-state-types/exitcode"
	"github.com/filecoin-project/go-state-types/network"
	vmr "github.com/filecoin-project/specs-actors/v7/actors/runtime"

	"github.com/filecoin-project/lotus/chain/actors"
	"github.com/filecoin-project/lotus/chain/actors/aerrors"
	"github.com/filecoin-project/lotus/chain/actors/builtin"
	"github.com/filecoin-project/lotus/chain/types"
)

type MethodMeta struct {
	Name string

	Params reflect.Type
	Ret    reflect.Type
}

type ActorRegistry struct {
	actors map[cid.Cid]*actorInfo

	Methods map[cid.Cid]map[abi.MethodNum]MethodMeta
}

// An ActorPredicate returns an error if the given actor is not valid for the given runtime environment (e.g., chain height, version, etc.).
type ActorPredicate func(vmr.Runtime, cid.Cid) error

func ActorsVersionPredicate(ver actorstypes.Version) ActorPredicate {
	return func(rt vmr.Runtime, codeCid cid.Cid) error {
		aver, err := actorstypes.VersionForNetwork(rt.NetworkVersion())
		if err != nil {
			return xerrors.Errorf("unsupported network version: %w", err)
		}
		if aver != ver {
			return xerrors.Errorf("actor %s is a version %d actor; chain only supports actor version %d at height %d and nver %d", codeCid, ver, aver, rt.CurrEpoch(), rt.NetworkVersion())
		}
		return nil
	}
}

type invokeFunc func(rt vmr.Runtime, params []byte) ([]byte, aerrors.ActorError)
type nativeCode map[abi.MethodNum]invokeFunc

type actorInfo struct {
	methods nativeCode
	vmActor builtin.RegistryEntry
	// TODO: consider making this a network version range?
	predicate ActorPredicate
}

func NewActorRegistry() *ActorRegistry {
	return &ActorRegistry{
		actors:  make(map[cid.Cid]*actorInfo),
		Methods: map[cid.Cid]map[abi.MethodNum]MethodMeta{},
	}
}

func (ar *ActorRegistry) Invoke(codeCid cid.Cid, rt vmr.Runtime, method abi.MethodNum, params []byte) ([]byte, aerrors.ActorError) {
	act, ok := ar.actors[codeCid]
	if !ok {
		log.Errorf("no code for actor %s (Addr: %s)", codeCid, rt.Receiver())
		return nil, aerrors.Newf(exitcode.SysErrorIllegalActor, "no code for actor %s(%d)(%s)", codeCid, method, hex.EncodeToString(params))
	}
	if err := act.predicate(rt, codeCid); err != nil {
		return nil, aerrors.Newf(exitcode.SysErrorIllegalActor, "unsupported actor: %s", err)
	}
	if act.methods[method] == nil {
		return nil, aerrors.Newf(exitcode.SysErrInvalidMethod, "no method %d on actor", method)
	}
	return act.methods[method](rt, params)

}

func (ar *ActorRegistry) Register(av actorstypes.Version, pred ActorPredicate, vmactors []builtin.RegistryEntry) {
	if pred == nil {
		pred = func(vmr.Runtime, cid.Cid) error { return nil }
	}
	for _, a := range vmactors {

		var code nativeCode
		var err error
		if av <= actorstypes.Version7 {
			// register in the `actors` map (for the invoker)
			code, err = ar.transform(a)
			if err != nil {
				panic(xerrors.Errorf("%s: %w", string(a.Code().Hash()), err))
			}
		}

		ai := &actorInfo{
			methods:   code,
			vmActor:   a,
			predicate: pred,
		}

		ac := a.Code()
		ar.actors[ac] = ai

		// necessary to make stuff work
		var realCode cid.Cid
		if av >= actorstypes.Version8 {
			name := actors.CanonicalName(builtin.ActorNameByCode(ac))

			var ok bool
			realCode, ok = actors.GetActorCodeID(av, name)
			if ok {
				ar.actors[realCode] = ai
			}
		}

		// register in the `Methods` map (used by statemanager utils)
		exports := a.Exports()
		methods := make(map[abi.MethodNum]MethodMeta, len(exports))

		// Explicitly add send, it's special.
		methods[builtin.MethodSend] = MethodMeta{
			Name:   "Send",
			Params: reflect.TypeOf(new(abi.EmptyValue)),
			Ret:    reflect.TypeOf(new(abi.EmptyValue)),
		}

		// Iterate over exported methods. Some of these _may_ be nil and
		// must be skipped.
		for number, export := range exports {
			if export.Method == nil {
				continue
			}

			ev := reflect.ValueOf(export.Method)
			et := ev.Type()

			mm := MethodMeta{
				Name: export.Name,
				Ret:  et.Out(0),
			}

			if av <= actorstypes.Version7 {
				// methods exported from specs-actors have the runtime as the first param, so we want et.In(1)
				mm.Params = et.In(1)
			} else {
				// methods exported from go-state-types do not, so we want et.In(0)
				mm.Params = et.In(0)
			}

			methods[number] = mm
		}
		if realCode.Defined() {
			ar.Methods[realCode] = methods
		} else {
			ar.Methods[a.Code()] = methods
		}
	}
}

func (ar *ActorRegistry) Create(codeCid cid.Cid, rt vmr.Runtime) (*types.Actor, aerrors.ActorError) {
	act, ok := ar.actors[codeCid]
	if !ok {
		return nil, aerrors.Newf(exitcode.SysErrorIllegalArgument, "Can only create built-in actors.")
	}

	if err := act.predicate(rt, codeCid); err != nil {
		return nil, aerrors.Newf(exitcode.SysErrorIllegalArgument, "Cannot create actor: %w", err)
	}

	return &types.Actor{
		Code:    codeCid,
		Head:    EmptyObjectCid,
		Nonce:   0,
		Balance: abi.NewTokenAmount(0),
	}, nil
}

type invokee interface {
	Exports() map[abi.MethodNum]builtinst.MethodMeta
}

func (*ActorRegistry) transform(instance invokee) (nativeCode, error) {
	itype := reflect.TypeOf(instance)
	exports := instance.Exports()
	runtimeType := reflect.TypeOf((*vmr.Runtime)(nil)).Elem()
	for i, e := range exports {
		i := i
		m := e.Method
		newErr := func(format string, args ...interface{}) error {
			str := fmt.Sprintf(format, args...)
			return fmt.Errorf("transform(%s) export(%d): %s", itype.Name(), i, str)
		}

		if m == nil {
			continue
		}

		meth := reflect.ValueOf(m)
		t := meth.Type()
		if t.Kind() != reflect.Func {
			return nil, newErr("is not a function")
		}
		if t.NumIn() != 2 {
			return nil, newErr("wrong number of inputs should be: " +
				"vmr.Runtime, <parameter>")
		}
		if !runtimeType.Implements(t.In(0)) {
			return nil, newErr("first argument should be vmr.Runtime")
		}
		if t.In(1).Kind() != reflect.Ptr {
			return nil, newErr("second argument should be of kind reflect.Ptr")
		}

		if t.NumOut() != 1 {
			return nil, newErr("wrong number of outputs should be: " +
				"cbg.CBORMarshaler")
		}
		o0 := t.Out(0)
		if !o0.Implements(reflect.TypeOf((*cbg.CBORMarshaler)(nil)).Elem()) {
			return nil, newErr("output needs to implement cgb.CBORMarshaler")
		}
	}
	code := make(nativeCode, len(exports))
	for id, e := range exports {
		m := e.Method
		if m == nil {
			continue
		}
		meth := reflect.ValueOf(m)
		code[id] = reflect.MakeFunc(reflect.TypeOf((invokeFunc)(nil)),
			func(in []reflect.Value) []reflect.Value {
				paramT := meth.Type().In(1).Elem()
				param := reflect.New(paramT)

				rt := in[0].Interface().(*Runtime)
				inBytes := in[1].Interface().([]byte)
				if err := DecodeParams(inBytes, param.Interface()); err != nil {
					ec := exitcode.ErrSerialization
					if rt.NetworkVersion() < network.Version7 {
						ec = 1
					}
					aerr := aerrors.Absorb(err, ec, "failed to decode parameters")
					return []reflect.Value{
						reflect.ValueOf([]byte{}),
						// Below is a hack, fixed in Go 1.13
						// https://git.io/fjXU6
						reflect.ValueOf(&aerr).Elem(),
					}
				}
				rval, aerror := rt.shimCall(func() interface{} {
					ret := meth.Call([]reflect.Value{
						reflect.ValueOf(rt),
						param,
					})
					return ret[0].Interface()
				})

				return []reflect.Value{
					reflect.ValueOf(&rval).Elem(),
					reflect.ValueOf(&aerror).Elem(),
				}
			}).Interface().(invokeFunc)

	}
	return code, nil
}

func DecodeParams(b []byte, out interface{}) error {
	um, ok := out.(cbg.CBORUnmarshaler)
	if !ok {
		return fmt.Errorf("type %T does not implement UnmarshalCBOR", out)
	}

	return um.UnmarshalCBOR(bytes.NewReader(b))
}

func DumpActorState(i *ActorRegistry, act *types.Actor, b []byte) (interface{}, error) {
	actInfo, ok := i.actors[act.Code]
	if !ok {
		return nil, xerrors.Errorf("state type for actor %s not found", act.Code)
	}

	um := actInfo.vmActor.State()
	if um == nil {
		if act.Head != EmptyObjectCid {
			return nil, xerrors.Errorf("actor with code %s should only have empty object (%s) as its Head, instead has %s", act.Code, EmptyObjectCid, act.Head)
		}

		return nil, nil
	}
	if err := um.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
		return nil, xerrors.Errorf("unmarshaling actor state: %w", err)
	}

	return um, nil
}
