package skeleton

import (
	"context"
	"fmt"

	"github.com/sirupsen/logrus"

	"github.com/c9s/bbgo/pkg/bbgo"
	"github.com/c9s/bbgo/pkg/fixedpoint"
	"github.com/c9s/bbgo/pkg/types"
)

// ID is the unique strategy ID, it needs to be in all lower case
// For example, grid strategy uses "grid"
const ID = "skeleton"

// log is a logrus.Entry that will be reused.
// This line attaches the strategy field to the logger with our ID, so that the logs from this strategy will be tagged with our ID
var log = logrus.WithField("strategy", ID)

var ten = fixedpoint.NewFromInt(10)

// init is a special function of golang, it will be called when the program is started
// importing this package will trigger the init function call.
func init() {
	// Register our struct type to BBGO
	// Note that you don't need to field the fields.
	// BBGO uses reflect to parse your type information.
	bbgo.RegisterStrategy(ID, &Strategy{})
}

// State is a struct contains the information that we want to keep in the persistence layer,
// for example, redis or json file.
type State struct {
	Counter int `json:"counter,omitempty"`
}

// Strategy is a struct that contains the settings of your strategy.
// These settings will be loaded from the BBGO YAML config file "bbgo.yaml" automatically.
type Strategy struct {
	Symbol string `json:"symbol"`

	// State is a state of your strategy
	// When BBGO shuts down, everything in the memory will be dropped
	// If you need to store something and restore this information back,
	// Simply define the "persistence" tag
	State *State `persistence:"state"`
}

// ID should return the identity of this strategy
func (s *Strategy) ID() string {
	return ID
}

// InstanceID returns the identity of the current instance of this strategy.
// You may have multiple instance of a strategy, with different symbols and settings.
// This value will be used for persistence layer to separate the storage.
//
// Run:
//    redis-cli KEYS "*"
//
// And you will see how this instance ID is used in redis.
func (s *Strategy) InstanceID() string {
	return ID + ":" + s.Symbol
}

// Subscribe method subscribes specific market data from the given session.
// Before BBGO is connected to the exchange, we need to collect what we want to subscribe.
// Here the strategy needs kline data, so it adds the kline subscription.
func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
	// We want 1m kline data of the symbol
	// It will be BTCUSDT 1m if our s.Symbol is BTCUSDT
	session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: "1m"})
}

// This strategy simply spent all available quote currency to buy the symbol whenever kline gets closed
func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) error {
	// Initialize the default value for state
	if s.State == nil {
		s.State = &State{Counter: 1}
	}

	indicators := session.StandardIndicatorSet(s.Symbol)
	atr := indicators.ATR(types.IntervalWindow{
		Interval: types.Interval1m,
		Window:   14,
	})

	// To get the market information from the current session
	// The market object provides the precision, MoQ (minimal of quantity) information
	market, ok := session.Market(s.Symbol)
	if !ok {
		return fmt.Errorf("market %s not found", s.Symbol)
	}

	// here we define a kline callback
	// when a kline is closed, we will do something
	callback := func(kline types.KLine) {
		// get the latest ATR value from the indicator object that we just defined.
		atrValue := atr.Last()
		log.Infof("atr %f", atrValue)

		// Update our counter and sync the changes to the persistence layer on time
		// If you don't do this, BBGO will sync it automatically when BBGO shuts down.
		s.State.Counter++
		bbgo.Sync(ctx, s)

		// To check if we have the quote balance
		// When symbol = "BTCUSDT", the quote currency is USDT
		// We can get this information from the market object
		quoteBalance, ok := session.GetAccount().Balance(market.QuoteCurrency)
		if !ok {
			// if not ok, it means we don't have this currency in the account
			return
		}

		// For each balance, we have Available and Locked balance.
		// balance.Available is the balance you can use to place an order.
		// Note that the available balance is a fixed-point object, so you can not compare it with integer directly.
		// Instead, you should call valueA.Compare(valueB)
		quantityAmount := quoteBalance.Available
		if quantityAmount.Sign() <= 0 || quantityAmount.Compare(ten) < 0 {
			return
		}

		// Call LastPrice(symbol) If you need to get the latest price
		// Note this last price is updated by the closed kline
		currentPrice, ok := session.LastPrice(s.Symbol)
		if !ok {
			return
		}

		// totalQuantity = quantityAmount / currentPrice
		totalQuantity := quantityAmount.Div(currentPrice)

		// Place a market order to the exchange
		createdOrders, err := orderExecutor.SubmitOrders(ctx, types.SubmitOrder{
			Symbol:   kline.Symbol,
			Side:     types.SideTypeBuy,
			Type:     types.OrderTypeMarket,
			Price:    currentPrice,
			Quantity: totalQuantity,
		})

		if err != nil {
			log.WithError(err).Error("submit order error")
		}

		log.Infof("createdOrders: %+v", createdOrders)

		// send notification to slack or telegram if you have configured it
		bbgo.Notify("order created")
	}

	// register our kline event handler
	session.MarketDataStream.OnKLineClosed(callback)

	// if you need to do something when the user data stream is ready
	// note that you only receive order update, trade update, balance update when the user data stream is connect.
	session.UserDataStream.OnStart(func() {
		log.Infof("connected")
	})

	return nil
}