package client

import (
	"fmt"

	"github.com/nspcc-dev/neo-go/pkg/encoding/fixedn"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
)

// StaticClient is a wrapper over Neo:Morph client
// that invokes single smart contract methods with fixed fee.
//
// Working static client must be created via constructor NewStatic.
// Using the StaticClient that has been created with new(StaticClient)
// expression (or just declaring a StaticClient variable) is unsafe
// and can lead to panic.
type StaticClient struct {
	staticOpts

	client *Client // neo-go client instance

	scScriptHash util.Uint160 // contract script-hash
}

type staticOpts struct {
	tryNotary bool
	alpha     bool // use client's key to sign notary request's main TX

	fee fixedn.Fixed8
}

// WithNotary returns notary status of the client.
//
// See also TryNotary.
func (s *StaticClient) WithNotary() bool {
	return s.client.IsNotaryEnabled()
}

// IsAlpha returns Alphabet status of the client.
//
// See also AsAlphabet.
func (s *StaticClient) IsAlpha() bool {
	return s.alpha
}

// StaticClientOption allows to set an optional
// parameter of StaticClient.
type StaticClientOption func(*staticOpts)

// NewStatic creates, initializes and returns the StaticClient instance.
//
// If provided Client instance is nil, ErrNilClient is returned.
//
// Specified fee is used by default. Per-operation fees can be customized via WithCustomFee option.
func NewStatic(client *Client, scriptHash util.Uint160, fee fixedn.Fixed8, opts ...StaticClientOption) (*StaticClient, error) {
	if client == nil {
		return nil, ErrNilClient
	}

	c := &StaticClient{
		client:       client,
		scScriptHash: scriptHash,
	}

	c.fee = fee

	for i := range opts {
		opts[i](&c.staticOpts)
	}

	return c, nil
}

// Morph return wrapped raw morph client.
func (s StaticClient) Morph() *Client {
	return s.client
}

// InvokePrm groups parameters of the Invoke operation.
type InvokePrm struct {
	TestInvokePrm

	// optional parameters
	InvokePrmOptional
}

// InvokePrmOptional groups optional parameters of the Invoke operation.
type InvokePrmOptional struct {
	// hash is an optional hash of the transaction
	// that generated the notification that required
	// to invoke notary request.
	// It is used to generate same but unique nonce and
	// `validUntilBlock` values by all notification
	// receivers.
	hash *util.Uint256
	// controlTX controls whether the invoke method will use a rounded
	// block height value, which is useful for control transactions which
	// are required to be produced by all nodes with very high probability.
	// It's only used by notary transactions and it affects only the
	// computation of `validUntilBlock` values.
	controlTX bool
	// vub is used to set custom valid until block value.
	vub uint32
}

// SetHash sets optional hash of the transaction.
// If hash is set and notary is enabled, StaticClient
// uses it for notary nonce and `validUntilBlock`
// calculation.
func (i *InvokePrmOptional) SetHash(hash util.Uint256) {
	i.hash = &hash
}

// SetControlTX sets whether a control transaction will be used.
func (i *InvokePrmOptional) SetControlTX(b bool) {
	i.controlTX = b
}

// IsControl gets whether a control transaction will be used.
func (i *InvokePrmOptional) IsControl() bool {
	return i.controlTX
}

// SetVUB sets valid until block value.
func (i *InvokePrmOptional) SetVUB(v uint32) {
	i.vub = v
}

type InvokeRes struct {
	VUB uint32
}

// Invoke calls Invoke method of Client with static internal script hash and fee.
// Supported args types are the same as in Client.
//
// If TryNotary is provided:
//   - if AsAlphabet is provided, calls NotaryInvoke;
//   - otherwise, calls NotaryInvokeNotAlpha.
//
// If fee for the operation executed using specified method is customized, then StaticClient uses it.
// Otherwise, default fee is used.
func (s StaticClient) Invoke(prm InvokePrm) (InvokeRes, error) {
	var res InvokeRes
	var err error
	var vubP *uint32
	if s.tryNotary {
		if s.alpha {
			var (
				nonce uint32 = 1
				vub   uint32
				err   error
			)

			if prm.hash != nil {
				if prm.controlTX {
					nonce, vub, err = s.client.CalculateNonceAndVUBControl(*prm.hash)
				} else {
					nonce, vub, err = s.client.CalculateNonceAndVUB(*prm.hash)
				}
				if err != nil {
					return InvokeRes{}, fmt.Errorf("could not calculate nonce and VUB for notary alphabet invoke: %w", err)
				}

				vubP = &vub
			}

			if prm.vub > 0 {
				vubP = &prm.vub
			}

			res.VUB, err = s.client.NotaryInvoke(s.scScriptHash, s.fee, nonce, vubP, prm.method, prm.args...)
			return res, err
		}

		if prm.vub > 0 {
			vubP = &prm.vub
		}

		res.VUB, err = s.client.NotaryInvokeNotAlpha(s.scScriptHash, s.fee, vubP, prm.method, prm.args...)
		return res, err
	}

	res.VUB, err = s.client.Invoke(
		s.scScriptHash,
		s.fee,
		prm.method,
		prm.args...,
	)
	return res, err
}

// TestInvokePrm groups parameters of the TestInvoke operation.
type TestInvokePrm struct {
	method string
	args   []any
}

// SetMethod sets method of the contract to call.
func (ti *TestInvokePrm) SetMethod(method string) {
	ti.method = method
}

// SetArgs sets arguments of the contact call.
func (ti *TestInvokePrm) SetArgs(args ...any) {
	ti.args = args
}

// TestInvoke calls TestInvoke method of Client with static internal script hash.
func (s StaticClient) TestInvoke(prm TestInvokePrm) ([]stackitem.Item, error) {
	return s.client.TestInvoke(
		s.scScriptHash,
		prm.method,
		prm.args...,
	)
}

// ContractAddress returns the address of the associated contract.
func (s StaticClient) ContractAddress() util.Uint160 {
	return s.scScriptHash
}

// TryNotary returns option to enable
// notary invocation tries.
func TryNotary() StaticClientOption {
	return func(o *staticOpts) {
		o.tryNotary = true
	}
}

// AsAlphabet returns option to sign main TX
// of notary requests with client's private
// key.
//
// Considered to be used by IR nodes only.
func AsAlphabet() StaticClientOption {
	return func(o *staticOpts) {
		o.alpha = true
	}
}