package netmap

import (
	"context"
	"encoding/hex"

	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs"
	netmapclient "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client/netmap"
	netmapEvent "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/event/netmap"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
	"go.uber.org/zap"
)

// Process add peer notification by sanity check of new node
// local epoch timer.
func (np *Processor) processAddPeer(ctx context.Context, ev netmapEvent.AddPeer) bool {
	if !np.alphabetState.IsAlphabet(ctx) {
		np.log.Info(ctx, logs.NetmapNonAlphabetModeIgnoreNewPeerNotification)
		return true
	}

	// check if notary transaction is valid, see #976
	tx := ev.NotaryRequest().MainTransaction
	ok, err := np.netmapClient.MorphIsValidScript(tx.Script, tx.Signers)
	if err != nil || !ok {
		np.log.Warn(ctx, logs.NetmapNonhaltNotaryTransaction,
			zap.String("method", "netmap.AddPeer"),
			zap.String("hash", tx.Hash().StringLE()),
			zap.Error(err))
		return false
	}

	// unmarshal node info
	var nodeInfo netmap.NodeInfo
	if err := nodeInfo.Unmarshal(ev.Node()); err != nil {
		// it will be nice to have tx id at event structure to log it
		np.log.Warn(ctx, logs.NetmapCantParseNetworkMapCandidate)
		return false
	}

	// validate and update node info
	err = np.nodeValidator.VerifyAndUpdate(&nodeInfo)
	if err != nil {
		np.log.Warn(ctx, logs.NetmapCouldNotVerifyAndUpdateInformationAboutNetworkMapCandidate,
			zap.Error(err),
		)

		return false
	}

	// sort attributes to make it consistent
	nodeInfo.SortAttributes()

	// marshal updated node info structure
	nodeInfoBinary := nodeInfo.Marshal()

	keyString := netmap.StringifyPublicKey(nodeInfo)

	updated := np.netmapSnapshot.touch(keyString, np.epochState.EpochCounter(), nodeInfoBinary)

	// `processAddPeer` reacts on `AddPeer` notification, `processNewEpoch` - on `NewEpoch`.
	// This two notification produces in order - `NewEpoch` -> `AddPeer`.
	// But there is no guarantee that code will be executed in the same order.
	// That is why we need to perform `addPeerIR` only in case when node is online,
	// because in scope of this method, contract set state `ONLINE` for the node.
	if updated && nodeInfo.Status().IsOnline() {
		np.log.Info(ctx, logs.NetmapApprovingNetworkMapCandidate,
			zap.String("key", keyString))

		prm := netmapclient.AddPeerPrm{}
		prm.SetNodeInfo(nodeInfo)

		// In notary environments we call AddPeerIR method instead of AddPeer.
		// It differs from AddPeer only by name, so we can do this in the same form.
		// See https://github.com/nspcc-dev/frostfs-contract/issues/154.
		const methodAddPeerNotary = "addPeerIR"

		// create new notary request with the original nonce
		err = np.netmapClient.MorphNotaryInvoke(
			ctx,
			np.netmapClient.ContractAddress(),
			0,
			ev.NotaryRequest().MainTransaction.Nonce,
			nil,
			methodAddPeerNotary,
			nodeInfoBinary,
		)
		if err != nil {
			np.log.Error(ctx, logs.NetmapCantInvokeNetmapAddPeer, zap.Error(err))
			return false
		}
	}

	return true
}

// Process update peer notification by sending approval tx to the smart contract.
func (np *Processor) processUpdatePeer(ctx context.Context, ev netmapEvent.UpdatePeer) bool {
	if !np.alphabetState.IsAlphabet(ctx) {
		np.log.Info(ctx, logs.NetmapNonAlphabetModeIgnoreUpdatePeerNotification)
		return true
	}

	// flag node to remove from local view, so it can be re-bootstrapped
	// again before new epoch will tick
	np.netmapSnapshot.flag(hex.EncodeToString(ev.PublicKey().Bytes()))

	var err error

	if ev.Maintenance() {
		err = np.nodeStateSettings.MaintenanceModeAllowed()
		if err != nil {
			np.log.Info(ctx, logs.NetmapPreventSwitchingNodeToMaintenanceState,
				zap.Error(err),
			)

			return false
		}
	}

	if err = np.netmapClient.MorphNotarySignAndInvokeTX(ev.NotaryRequest().MainTransaction); err != nil {
		np.log.Error(ctx, logs.NetmapCantInvokeNetmapUpdatePeer, zap.Error(err))
		return false
	}

	return true
}