package netmap

import (
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neofs-node/pkg/innerring/timers"
	"github.com/nspcc-dev/neofs-node/pkg/morph/client"
	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
	netmapEvent "github.com/nspcc-dev/neofs-node/pkg/morph/event/netmap"
	"github.com/panjf2000/ants/v2"
	"github.com/pkg/errors"
	"go.uber.org/zap"
)

type (
	// EpochTimerReseter is a callback interface for tickers component.
	EpochTimerReseter interface {
		ResetEpochTimer()
	}

	// EpochState is a callback interface for inner ring global state.
	EpochState interface {
		SetEpochCounter(uint64)
		EpochCounter() uint64
	}

	// ActiveState is a callback interface for inner ring global state.
	ActiveState interface {
		IsActive() bool
	}

	// Processor of events produced by network map contract
	// and new epoch ticker, because it is related to contract.
	Processor struct {
		log            *zap.Logger
		pool           *ants.Pool
		netmapContract util.Uint160
		epochTimer     EpochTimerReseter
		epochState     EpochState
		activeState    ActiveState
		morphClient    *client.Client
	}

	// Params of the processor constructor.
	Params struct {
		Log            *zap.Logger
		PoolSize       int
		NetmapContract util.Uint160
		EpochTimer     EpochTimerReseter
		MorphClient    *client.Client
		EpochState     EpochState
		ActiveState    ActiveState
	}
)

const (
	newEpochNotification = "NewEpoch"
)

// New creates network map contract processor instance.
func New(p *Params) (*Processor, error) {
	switch {
	case p.Log == nil:
		return nil, errors.New("ir/netmap: logger is not set")
	case p.MorphClient == nil:
		return nil, errors.New("ir/netmap: morph client is not set")
	case p.EpochTimer == nil:
		return nil, errors.New("ir/netmap: epoch itmer is not set")
	case p.EpochState == nil:
		return nil, errors.New("ir/netmap: global state is not set")
	case p.ActiveState == nil:
		return nil, errors.New("ir/netmap: global state is not set")
	}

	p.Log.Debug("netmap worker pool", zap.Int("size", p.PoolSize))

	pool, err := ants.NewPool(p.PoolSize, ants.WithNonblocking(true))
	if err != nil {
		return nil, errors.Wrap(err, "ir/netmap: can't create worker pool")
	}

	return &Processor{
		log:            p.Log,
		pool:           pool,
		netmapContract: p.NetmapContract,
		epochTimer:     p.EpochTimer,
		epochState:     p.EpochState,
		activeState:    p.ActiveState,
		morphClient:    p.MorphClient,
	}, nil
}

// ListenerParsers for the 'event.Listener' event producer.
func (np *Processor) ListenerParsers() []event.ParserInfo {
	var parsers []event.ParserInfo

	// new epoch event
	newEpoch := event.ParserInfo{}
	newEpoch.SetType(newEpochNotification)
	newEpoch.SetScriptHash(np.netmapContract)
	newEpoch.SetParser(netmapEvent.ParseNewEpoch)
	parsers = append(parsers, newEpoch)

	return parsers
}

// ListenerHandlers for the 'event.Listener' event producer.
func (np *Processor) ListenerHandlers() []event.HandlerInfo {
	var handlers []event.HandlerInfo

	// new epoch handler
	newEpoch := event.HandlerInfo{}
	newEpoch.SetType(newEpochNotification)
	newEpoch.SetScriptHash(np.netmapContract)
	newEpoch.SetHandler(np.handleNewEpoch)
	handlers = append(handlers, newEpoch)

	return handlers
}

// TimersHandlers for the 'Timers' event producer.
func (np *Processor) TimersHandlers() []event.HandlerInfo {
	var handlers []event.HandlerInfo

	// new epoch handler
	newEpoch := event.HandlerInfo{}
	newEpoch.SetType(timers.EpochTimer)
	newEpoch.SetHandler(np.handleNewEpochTick)
	handlers = append(handlers, newEpoch)

	return handlers
}