package frostfsid

import (
	"errors"
	"fmt"

	frostfsidclient "git.frostfs.info/TrueCloudLab/frostfs-contract/frostfsid/client"
	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client"
	"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
	"github.com/nspcc-dev/neo-go/pkg/vm/vmstate"
)

const methodGetSubject = "getSubject"

func (c *Client) GetSubject(addr util.Uint160) (*frostfsidclient.Subject, error) {
	prm := client.TestInvokePrm{}
	prm.SetMethod(methodGetSubject)
	prm.SetArgs(addr)

	res, err := c.client.TestInvoke(prm)
	if err != nil {
		return nil, fmt.Errorf("could not perform test invocation (%s): %w", methodGetSubject, err)
	}

	subj, err := parseSubject(res)
	if err != nil {
		return nil, fmt.Errorf("could not parse test invocation result (%s): %w", methodGetSubject, err)
	}

	return subj, nil
}

func parseSubject(res []stackitem.Item) (*frostfsidclient.Subject, error) {
	if ln := len(res); ln != 1 {
		return nil, fmt.Errorf("unexpected stack item count (%s): %d", methodGetSubject, ln)
	}

	structArr, err := client.ArrayFromStackItem(res[0])
	if err != nil {
		return nil, fmt.Errorf("could not get item array of container (%s): %w", methodGetSubject, err)
	}

	var subj frostfsidclient.Subject

	subj.PrimaryKey, err = unwrap.PublicKey(makeValidRes(structArr[0]))
	if err != nil {
		return nil, err
	}

	if !structArr[1].Equals(stackitem.Null{}) {
		subj.AdditionalKeys, err = unwrap.ArrayOfPublicKeys(makeValidRes(structArr[1]))
		if err != nil {
			return nil, err
		}
	}

	if !structArr[2].Equals(stackitem.Null{}) {
		subj.Namespace, err = unwrap.UTF8String(makeValidRes(structArr[2]))
		if err != nil {
			return nil, err
		}
	}

	if !structArr[3].Equals(stackitem.Null{}) {
		subj.Name, err = unwrap.UTF8String(makeValidRes(structArr[3]))
		if err != nil {
			return nil, err
		}
	}

	subj.KV, err = parseMap(structArr[4])
	if err != nil {
		return nil, err
	}

	return &subj, nil
}

func makeValidRes(item stackitem.Item) (*result.Invoke, error) {
	return &result.Invoke{
		Stack: []stackitem.Item{item},
		State: vmstate.Halt.String(),
	}, nil
}

func parseMap(item stackitem.Item) (map[string]string, error) {
	if item.Equals(stackitem.Null{}) {
		return nil, nil
	}

	metaMap, err := unwrap.Map(makeValidRes(item))
	if err != nil {
		return nil, err
	}

	meta, ok := metaMap.Value().([]stackitem.MapElement)
	if !ok {
		return nil, errors.New("invalid map type")
	}

	res := make(map[string]string, len(meta))
	for _, element := range meta {
		key, err := element.Key.TryBytes()
		if err != nil {
			return nil, err
		}
		val, err := element.Value.TryBytes()
		if err != nil {
			return nil, err
		}
		res[string(key)] = string(val)
	}

	return res, nil
}