package linregmaker

import (
	"context"
	"fmt"
	"github.com/c9s/bbgo/pkg/risk/dynamicrisk"
	"sync"

	"github.com/c9s/bbgo/pkg/indicator"
	"github.com/c9s/bbgo/pkg/util"

	"github.com/pkg/errors"
	"github.com/sirupsen/logrus"

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

// TODO: Docs

const ID = "linregmaker"

var notionModifier = fixedpoint.NewFromFloat(1.1)
var two = fixedpoint.NewFromInt(2)

var log = logrus.WithField("strategy", ID)

func init() {
	bbgo.RegisterStrategy(ID, &Strategy{})
}

type Strategy struct {
	// Symbol is the market symbol you want to trade
	Symbol string `json:"symbol"`

	// Leverage uses the account net value to calculate the allowed margin
	Leverage fixedpoint.Value `json:"leverage"`

	types.IntervalWindow

	// ReverseEMA is used to determine the long-term trend.
	// Above the ReverseEMA is the long trend and vise versa.
	// All the opposite trend position will be closed upon the trend change
	ReverseEMA *indicator.EWMA `json:"reverseEMA"`

	// ReverseInterval is the interval to check trend reverse against ReverseEMA. Close price of this interval crossing
	// the ReverseEMA triggers main trend change.
	ReverseInterval types.Interval `json:"reverseInterval"`

	// mainTrendCurrent is the current long-term trend
	mainTrendCurrent types.Direction
	// mainTrendPrevious is the long-term trend of previous kline
	mainTrendPrevious types.Direction

	// FastLinReg is to determine the short-term trend.
	// Buy/sell orders are placed if the FastLinReg and the ReverseEMA trend are in the same direction, and only orders
	// that reduce position are placed if the FastLinReg and the ReverseEMA trend are in different directions.
	FastLinReg *indicator.LinReg `json:"fastLinReg"`

	// SlowLinReg is to determine the midterm trend.
	// When the SlowLinReg and the ReverseEMA trend are in different directions, creation of opposite position is
	// allowed.
	SlowLinReg *indicator.LinReg `json:"slowLinReg"`

	// AllowOppositePosition if true, the creation of opposite position is allowed when both fast and slow LinReg are in
	// the opposite direction to main trend
	AllowOppositePosition bool `json:"allowOppositePosition"`

	// FasterDecreaseRatio the quantity of decreasing position orders are multiplied by this ratio when both fast and
	// slow LinReg are in the opposite direction to main trend
	FasterDecreaseRatio fixedpoint.Value `json:"fasterDecreaseRatio,omitempty"`

	// NeutralBollinger is the smaller range of the bollinger band
	// If price is in this band, it usually means the price is oscillating.
	// If price goes out of this band, we tend to not place sell orders or buy orders
	NeutralBollinger types.IntervalWindowBandWidth `json:"neutralBollinger"`

	// neutralBoll is the neutral price section for TradeInBand
	neutralBoll *indicator.BOLL

	// TradeInBand
	// When this is on, places orders only when the current price is in the bollinger band.
	TradeInBand bool `json:"tradeInBand"`

	// Spread is the price spread from the middle price.
	// For ask orders, the ask price is ((bestAsk + bestBid) / 2 * (1.0 + spread))
	// For bid orders, the bid price is ((bestAsk + bestBid) / 2 * (1.0 - spread))
	// Spread can be set by percentage or floating number. e.g., 0.1% or 0.001
	Spread fixedpoint.Value `json:"spread"`

	// BidSpread overrides the spread setting, this spread will be used for the buy order
	BidSpread fixedpoint.Value `json:"bidSpread,omitempty"`

	// AskSpread overrides the spread setting, this spread will be used for the sell order
	AskSpread fixedpoint.Value `json:"askSpread,omitempty"`

	// DynamicSpread enables the automatic adjustment to bid and ask spread.
	// Overrides Spread, BidSpread, and AskSpread
	DynamicSpread dynamicrisk.DynamicSpread `json:"dynamicSpread,omitempty"`

	// MaxExposurePosition is the maximum position you can hold
	// 10 means you can hold 10 ETH long/short position by maximum
	MaxExposurePosition fixedpoint.Value `json:"maxExposurePosition"`

	// DynamicExposure is used to define the exposure position range with the given percentage.
	// When DynamicExposure is set, your MaxExposurePosition will be calculated dynamically
	DynamicExposure dynamicrisk.DynamicExposure `json:"dynamicExposure"`

	bbgo.QuantityOrAmount

	// DynamicQuantityIncrease calculates the increase position order quantity dynamically
	DynamicQuantityIncrease dynamicrisk.DynamicQuantitySet `json:"dynamicQuantityIncrease"`

	// DynamicQuantityDecrease calculates the decrease position order quantity dynamically
	DynamicQuantityDecrease dynamicrisk.DynamicQuantitySet `json:"dynamicQuantityDecrease"`

	// UseDynamicQuantityAsAmount calculates amount instead of quantity
	UseDynamicQuantityAsAmount bool `json:"useDynamicQuantityAsAmount"`

	// MinProfitSpread is the minimal order price spread from the current average cost.
	// For long position, you will only place sell order above the price (= average cost * (1 + minProfitSpread))
	// For short position, you will only place buy order below the price (= average cost * (1 - minProfitSpread))
	MinProfitSpread fixedpoint.Value `json:"minProfitSpread"`

	// MinProfitActivationRate activates MinProfitSpread when position RoI higher than the specified percentage
	MinProfitActivationRate fixedpoint.Value `json:"minProfitActivationRate"`

	// ExitMethods are various TP/SL methods
	ExitMethods bbgo.ExitMethodSet `json:"exits"`

	// persistence fields
	Position    *types.Position    `persistence:"position"`
	ProfitStats *types.ProfitStats `persistence:"profit_stats"`
	TradeStats  *types.TradeStats  `persistence:"trade_stats"`

	Environment          *bbgo.Environment
	StandardIndicatorSet *bbgo.StandardIndicatorSet
	Market               types.Market
	ctx                  context.Context

	session *bbgo.ExchangeSession

	orderExecutor *bbgo.GeneralOrderExecutor

	groupID uint32

	// StrategyController
	bbgo.StrategyController
}

func (s *Strategy) ID() string {
	return ID
}

func (s *Strategy) InstanceID() string {
	return fmt.Sprintf("%s:%s", ID, s.Symbol)
}

// Validate basic config parameters
func (s *Strategy) Validate() error {
	if len(s.Symbol) == 0 {
		return errors.New("symbol is required")
	}

	if len(s.Interval) == 0 {
		return errors.New("interval is required")
	}

	if s.ReverseEMA == nil {
		return errors.New("reverseEMA must be set")
	}

	if s.FastLinReg == nil {
		return errors.New("fastLinReg must be set")
	}

	if s.SlowLinReg == nil {
		return errors.New("slowLinReg must be set")
	}

	return nil
}

func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
	// Subscribe for ReverseEMA
	session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{
		Interval: s.ReverseEMA.Interval,
	})

	// Subscribe for ReverseInterval. Use interval of ReverseEMA if ReverseInterval is omitted
	if s.ReverseInterval == "" {
		s.ReverseInterval = s.ReverseEMA.Interval
	}
	session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{
		Interval: s.ReverseInterval,
	})

	// Subscribe for LinRegs
	session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{
		Interval: s.FastLinReg.Interval,
	})
	session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{
		Interval: s.SlowLinReg.Interval,
	})
	// Initialize LinRegs
	kLineStore, _ := session.MarketDataStore(s.Symbol)
	s.FastLinReg.BindK(session.MarketDataStream, s.Symbol, s.FastLinReg.Interval)
	if klines, ok := kLineStore.KLinesOfInterval(s.FastLinReg.Interval); ok {
		s.FastLinReg.LoadK((*klines)[0:])
	}
	s.SlowLinReg.BindK(session.MarketDataStream, s.Symbol, s.SlowLinReg.Interval)
	if klines, ok := kLineStore.KLinesOfInterval(s.SlowLinReg.Interval); ok {
		s.SlowLinReg.LoadK((*klines)[0:])
	}

	// Subscribe for BBs
	if s.NeutralBollinger.Interval != "" {
		session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{
			Interval: s.NeutralBollinger.Interval,
		})
	}

	// Setup Exits
	s.ExitMethods.SetAndSubscribe(session, s)

	// Setup dynamic spread
	if s.DynamicSpread.IsEnabled() {
		s.DynamicSpread.Initialize(s.Symbol, session)
	}

	// Setup dynamic exposure
	if s.DynamicExposure.IsEnabled() {
		s.DynamicExposure.Initialize(s.Symbol, session)
	}

	// Setup dynamic quantities
	if len(s.DynamicQuantityIncrease) > 0 {
		s.DynamicQuantityIncrease.Initialize(s.Symbol, session)
	}
	if len(s.DynamicQuantityDecrease) > 0 {
		s.DynamicQuantityDecrease.Initialize(s.Symbol, session)
	}
}

func (s *Strategy) CurrentPosition() *types.Position {
	return s.Position
}

func (s *Strategy) ClosePosition(ctx context.Context, percentage fixedpoint.Value) error {
	return s.orderExecutor.ClosePosition(ctx, percentage)
}

// isAllowOppositePosition returns if opening opposite position is allowed
func (s *Strategy) isAllowOppositePosition() bool {
	if !s.AllowOppositePosition {
		return false
	}

	if (s.mainTrendCurrent == types.DirectionUp && s.FastLinReg.Last(0) < 0 && s.SlowLinReg.Last(0) < 0) ||
		(s.mainTrendCurrent == types.DirectionDown && s.FastLinReg.Last(0) > 0 && s.SlowLinReg.Last(0) > 0) {
		log.Infof("%s allow opposite position is enabled: MainTrend %v, FastLinReg: %f, SlowLinReg: %f", s.Symbol, s.mainTrendCurrent, s.FastLinReg.Last(0), s.SlowLinReg.Last(0))
		return true
	}
	log.Infof("%s allow opposite position is disabled: MainTrend %v, FastLinReg: %f, SlowLinReg: %f", s.Symbol, s.mainTrendCurrent, s.FastLinReg.Last(0), s.SlowLinReg.Last(0))

	return false
}

// updateSpread for ask and bid price
func (s *Strategy) updateSpread() {
	// Update spreads with dynamic spread
	if s.DynamicSpread.IsEnabled() {
		dynamicBidSpread, err := s.DynamicSpread.GetBidSpread()
		if err == nil && dynamicBidSpread > 0 {
			s.BidSpread = fixedpoint.NewFromFloat(dynamicBidSpread)
			log.Infof("%s dynamic bid spread updated: %s", s.Symbol, s.BidSpread.Percentage())
		}
		dynamicAskSpread, err := s.DynamicSpread.GetAskSpread()
		if err == nil && dynamicAskSpread > 0 {
			s.AskSpread = fixedpoint.NewFromFloat(dynamicAskSpread)
			log.Infof("%s dynamic ask spread updated: %s", s.Symbol, s.AskSpread.Percentage())
		}
	}

	if s.BidSpread.Sign() <= 0 {
		s.BidSpread = s.Spread
	}

	if s.BidSpread.Sign() <= 0 {
		s.AskSpread = s.Spread
	}
}

// updateMaxExposure with dynamic exposure
func (s *Strategy) updateMaxExposure(midPrice fixedpoint.Value) {
	// Calculate max exposure
	if s.DynamicExposure.IsEnabled() {
		var err error
		maxExposurePosition, err := s.DynamicExposure.GetMaxExposure(midPrice.Float64(), s.mainTrendCurrent)
		if err != nil {
			log.WithError(err).Errorf("can not calculate DynamicExposure of %s, use previous MaxExposurePosition instead", s.Symbol)
			bbgo.Notify("can not calculate DynamicExposure of %s, use previous MaxExposurePosition instead", s.Symbol)
		} else {
			s.MaxExposurePosition = maxExposurePosition
		}
		log.Infof("calculated %s max exposure position: %v", s.Symbol, s.MaxExposurePosition)
	}
}

// getOrderPrices returns ask and bid prices
func (s *Strategy) getOrderPrices(midPrice fixedpoint.Value) (askPrice fixedpoint.Value, bidPrice fixedpoint.Value) {
	askPrice = midPrice.Mul(fixedpoint.One.Add(s.AskSpread))
	bidPrice = midPrice.Mul(fixedpoint.One.Sub(s.BidSpread))
	log.Infof("%s mid price:%v ask:%v bid: %v", s.Symbol, midPrice, askPrice, bidPrice)

	return askPrice, bidPrice
}

// adjustQuantity to meet the min notional and qty requirement
func (s *Strategy) adjustQuantity(quantity, price fixedpoint.Value) fixedpoint.Value {
	adjustedQty := quantity
	if quantity.Mul(price).Compare(s.Market.MinNotional) < 0 {
		adjustedQty = bbgo.AdjustFloatQuantityByMinAmount(quantity, price, s.Market.MinNotional.Mul(notionModifier))
	}

	if adjustedQty.Compare(s.Market.MinQuantity) < 0 {
		adjustedQty = fixedpoint.Max(adjustedQty, s.Market.MinQuantity)
	}

	return adjustedQty
}

// getOrderQuantities returns sell and buy qty
func (s *Strategy) getOrderQuantities(askPrice fixedpoint.Value, bidPrice fixedpoint.Value) (sellQuantity fixedpoint.Value, buyQuantity fixedpoint.Value) {
	// Default
	sellQuantity = s.QuantityOrAmount.CalculateQuantity(askPrice)
	buyQuantity = s.QuantityOrAmount.CalculateQuantity(bidPrice)

	// Dynamic qty
	switch {
	case s.mainTrendCurrent == types.DirectionUp:
		if len(s.DynamicQuantityIncrease) > 0 {
			qty, err := s.DynamicQuantityIncrease.GetQuantity(false)
			if err == nil {
				buyQuantity = qty
			} else {
				log.WithError(err).Errorf("cannot get dynamic buy qty of %s, use default qty instead", s.Symbol)
				bbgo.Notify("cannot get dynamic buy qty of %s, use default qty instead", s.Symbol)
			}
		}
		if len(s.DynamicQuantityDecrease) > 0 {
			qty, err := s.DynamicQuantityDecrease.GetQuantity(false)
			if err == nil {
				sellQuantity = qty
			} else {
				log.WithError(err).Errorf("cannot get dynamic sell qty of %s, use default qty instead", s.Symbol)
				bbgo.Notify("cannot get dynamic sell qty of %s, use default qty instead", s.Symbol)
			}
		}
	case s.mainTrendCurrent == types.DirectionDown:
		if len(s.DynamicQuantityIncrease) > 0 {
			qty, err := s.DynamicQuantityIncrease.GetQuantity(true)
			if err == nil {
				sellQuantity = qty
			} else {
				log.WithError(err).Errorf("cannot get dynamic sell qty of %s, use default qty instead", s.Symbol)
				bbgo.Notify("cannot get dynamic sell qty of %s, use default qty instead", s.Symbol)
			}
		}
		if len(s.DynamicQuantityDecrease) > 0 {
			qty, err := s.DynamicQuantityDecrease.GetQuantity(true)
			if err == nil {
				buyQuantity = qty
			} else {
				log.WithError(err).Errorf("cannot get dynamic buy qty of %s, use default qty instead", s.Symbol)
				bbgo.Notify("cannot get dynamic buy qty of %s, use default qty instead", s.Symbol)
			}
		}
	}
	if s.UseDynamicQuantityAsAmount {
		log.Infof("caculated %s buy amount %v, sell amount %v", s.Symbol, buyQuantity, sellQuantity)
		qtyAmount := bbgo.QuantityOrAmount{Amount: buyQuantity}
		buyQuantity = qtyAmount.CalculateQuantity(bidPrice)
		qtyAmount.Amount = sellQuantity
		sellQuantity = qtyAmount.CalculateQuantity(askPrice)
		log.Infof("convert %s amount to buy qty %v, sell qty %v", s.Symbol, buyQuantity, sellQuantity)
	} else {
		log.Infof("caculated %s buy qty %v, sell qty %v", s.Symbol, buyQuantity, sellQuantity)
	}

	// Faster position decrease
	if s.mainTrendCurrent == types.DirectionUp && s.SlowLinReg.Last(0) < 0 {
		sellQuantity = sellQuantity.Mul(s.FasterDecreaseRatio)
		log.Infof("faster %s position decrease: sell qty %v", s.Symbol, sellQuantity)
	} else if s.mainTrendCurrent == types.DirectionDown && s.SlowLinReg.Last(0) > 0 {
		buyQuantity = buyQuantity.Mul(s.FasterDecreaseRatio)
		log.Infof("faster %s position decrease: buy qty %v", s.Symbol, buyQuantity)
	}

	// Reduce order qty to fit current position
	if !s.isAllowOppositePosition() {
		if s.Position.IsLong() && s.Position.Base.Abs().Compare(sellQuantity) < 0 {
			sellQuantity = s.Position.Base.Abs()
		} else if s.Position.IsShort() && s.Position.Base.Abs().Compare(buyQuantity) < 0 {
			buyQuantity = s.Position.Base.Abs()
		}
	}

	if buyQuantity.Compare(fixedpoint.Zero) > 0 {
		buyQuantity = s.adjustQuantity(buyQuantity, bidPrice)
	}
	if sellQuantity.Compare(fixedpoint.Zero) > 0 {
		sellQuantity = s.adjustQuantity(sellQuantity, askPrice)
	}

	log.Infof("adjusted sell qty:%v buy qty: %v", sellQuantity, buyQuantity)

	return sellQuantity, buyQuantity
}

// getAllowedBalance returns the allowed qty of orders
func (s *Strategy) getAllowedBalance() (baseQty, quoteQty fixedpoint.Value) {
	// Default
	baseQty = fixedpoint.PosInf
	quoteQty = fixedpoint.PosInf

	balances := s.session.GetAccount().Balances()
	baseBalance, hasBaseBalance := balances[s.Market.BaseCurrency]
	quoteBalance, hasQuoteBalance := balances[s.Market.QuoteCurrency]
	lastPrice, _ := s.session.LastPrice(s.Symbol)

	if bbgo.IsBackTesting { // Backtesting
		baseQty = s.Position.Base
		quoteQty = quoteBalance.Available.Sub(fixedpoint.Max(s.Position.Quote.Mul(fixedpoint.Two), fixedpoint.Zero))
	} else if s.session.Margin || s.session.IsolatedMargin || s.session.Futures || s.session.IsolatedFutures { // Leveraged
		quoteQ, err := bbgo.CalculateQuoteQuantity(s.ctx, s.session, s.Market.QuoteCurrency, s.Leverage)
		if err != nil {
			quoteQ = fixedpoint.Zero
		}
		quoteQty = quoteQ
		baseQty = quoteQ.Div(lastPrice)
	} else { // Spot
		if !hasBaseBalance {
			baseQty = fixedpoint.Zero
		} else {
			baseQty = baseBalance.Available
		}
		if !hasQuoteBalance {
			quoteQty = fixedpoint.Zero
		} else {
			quoteQty = quoteBalance.Available
		}
	}

	return baseQty, quoteQty
}

// getCanBuySell returns the buy sell switches
func (s *Strategy) getCanBuySell(buyQuantity, bidPrice, sellQuantity, askPrice, midPrice fixedpoint.Value) (canBuy bool, canSell bool) {
	// By default, both buy and sell are on, which means we will place buy and sell orders
	canBuy = true
	canSell = true

	// Check if current position > maxExposurePosition
	if s.Position.GetBase().Abs().Compare(s.MaxExposurePosition) > 0 {
		if s.Position.IsLong() {
			canBuy = false
		} else if s.Position.IsShort() {
			canSell = false
		}
		log.Infof("current position %v larger than max exposure %v, skip increase position", s.Position.GetBase().Abs(), s.MaxExposurePosition)
	}

	// Check TradeInBand
	if s.TradeInBand {
		// Price too high
		if bidPrice.Float64() > s.neutralBoll.UpBand.Last(0) {
			canBuy = false
			log.Infof("tradeInBand is set, skip buy due to the price is higher than the neutralBB")
		}
		// Price too low in uptrend
		if askPrice.Float64() < s.neutralBoll.DownBand.Last(0) {
			canSell = false
			log.Infof("tradeInBand is set, skip sell due to the price is lower than the neutralBB")
		}
	}

	// Stop decrease when position closed unless both LinRegs are in the opposite direction to the main trend
	if !s.isAllowOppositePosition() {
		if s.mainTrendCurrent == types.DirectionUp && (s.Position.IsClosed() || s.Position.IsDust(askPrice)) {
			canSell = false
			log.Infof("skip sell due to the long position is closed")
		} else if s.mainTrendCurrent == types.DirectionDown && (s.Position.IsClosed() || s.Position.IsDust(bidPrice)) {
			canBuy = false
			log.Infof("skip buy due to the short position is closed")
		}
	}

	// Min profit
	roi := s.Position.ROI(midPrice)
	if roi.Compare(s.MinProfitActivationRate) >= 0 {
		if s.Position.IsLong() && !s.Position.IsDust(askPrice) {
			minProfitPrice := s.Position.AverageCost.Mul(fixedpoint.One.Add(s.MinProfitSpread))
			if askPrice.Compare(minProfitPrice) < 0 {
				canSell = false
				log.Infof("askPrice %v is less than minProfitPrice %v. skip sell", askPrice, minProfitPrice)
			}
		} else if s.Position.IsShort() && s.Position.IsDust(bidPrice) {
			minProfitPrice := s.Position.AverageCost.Mul(fixedpoint.One.Sub(s.MinProfitSpread))
			if bidPrice.Compare(minProfitPrice) > 0 {
				canBuy = false
				log.Infof("bidPrice %v is greater than minProfitPrice %v. skip buy", bidPrice, minProfitPrice)
			}
		}
	} else {
		log.Infof("position RoI %v is less than minProfitActivationRate %v. min profit protection is not active", roi, s.MinProfitActivationRate)
	}

	// Check against account balance
	baseQty, quoteQty := s.getAllowedBalance()
	if s.session.Margin || s.session.IsolatedMargin || s.session.Futures || s.session.IsolatedFutures { // Leveraged
		if quoteQty.Compare(fixedpoint.Zero) <= 0 {
			if s.Position.IsLong() {
				canBuy = false
				log.Infof("skip buy due to the account has no available balance")
			} else if s.Position.IsShort() {
				canSell = false
				log.Infof("skip sell due to the account has no available balance")
			}
		}
	} else {
		if buyQuantity.Compare(quoteQty.Div(bidPrice)) > 0 { // Spot
			canBuy = false
			log.Infof("skip buy due to the account has no available balance")
		}
		if sellQuantity.Compare(baseQty) > 0 {
			canSell = false
			log.Infof("skip sell due to the account has no available balance")
		}
	}

	log.Infof("canBuy %t, canSell %t", canBuy, canSell)
	return canBuy, canSell
}

// getOrderForms returns buy and sell order form for submission
func (s *Strategy) getOrderForms(buyQuantity, bidPrice, sellQuantity, askPrice fixedpoint.Value) (buyOrder types.SubmitOrder, sellOrder types.SubmitOrder) {
	sellOrder = types.SubmitOrder{
		Symbol:   s.Symbol,
		Side:     types.SideTypeSell,
		Type:     types.OrderTypeLimitMaker,
		Quantity: sellQuantity,
		Price:    askPrice,
		Market:   s.Market,
		GroupID:  s.groupID,
	}
	buyOrder = types.SubmitOrder{
		Symbol:   s.Symbol,
		Side:     types.SideTypeBuy,
		Type:     types.OrderTypeLimitMaker,
		Quantity: buyQuantity,
		Price:    bidPrice,
		Market:   s.Market,
		GroupID:  s.groupID,
	}

	isMargin := s.session.Margin || s.session.IsolatedMargin
	isFutures := s.session.Futures || s.session.IsolatedFutures

	if s.Position.IsClosed() {
		if isMargin {
			buyOrder.MarginSideEffect = types.SideEffectTypeMarginBuy
			sellOrder.MarginSideEffect = types.SideEffectTypeMarginBuy
		} else if isFutures {
			buyOrder.ReduceOnly = false
			sellOrder.ReduceOnly = false
		}
	} else if s.Position.IsLong() {
		if isMargin {
			buyOrder.MarginSideEffect = types.SideEffectTypeMarginBuy
			sellOrder.MarginSideEffect = types.SideEffectTypeAutoRepay
		} else if isFutures {
			buyOrder.ReduceOnly = false
			sellOrder.ReduceOnly = true
		}

		if s.Position.Base.Abs().Compare(sellOrder.Quantity) < 0 {
			if isMargin {
				sellOrder.MarginSideEffect = types.SideEffectTypeMarginBuy
			} else if isFutures {
				sellOrder.ReduceOnly = false
			}
		}
	} else if s.Position.IsShort() {
		if isMargin {
			buyOrder.MarginSideEffect = types.SideEffectTypeAutoRepay
			sellOrder.MarginSideEffect = types.SideEffectTypeMarginBuy
		} else if isFutures {
			buyOrder.ReduceOnly = true
			sellOrder.ReduceOnly = false
		}

		if s.Position.Base.Abs().Compare(buyOrder.Quantity) < 0 {
			if isMargin {
				sellOrder.MarginSideEffect = types.SideEffectTypeMarginBuy
			} else if isFutures {
				sellOrder.ReduceOnly = false
			}
		}
	}

	return buyOrder, sellOrder
}

func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) error {
	log.Debugf("%v", orderExecutor) // Here just to suppress GoLand warning
	// initial required information
	s.session = session
	s.ctx = ctx

	// Calculate group id for orders
	instanceID := s.InstanceID()
	s.groupID = util.FNV32(instanceID)

	// If position is nil, we need to allocate a new position for calculation
	if s.Position == nil {
		s.Position = types.NewPositionFromMarket(s.Market)
	}

	// Set fee rate
	if s.session.MakerFeeRate.Sign() > 0 || s.session.TakerFeeRate.Sign() > 0 {
		s.Position.SetExchangeFeeRate(s.session.ExchangeName, types.ExchangeFee{
			MakerFeeRate: s.session.MakerFeeRate,
			TakerFeeRate: s.session.TakerFeeRate,
		})
	}

	// If position is nil, we need to allocate a new position for calculation
	if s.Position == nil {
		s.Position = types.NewPositionFromMarket(s.Market)
	}
	// Always update the position fields
	s.Position.Strategy = ID
	s.Position.StrategyInstanceID = s.InstanceID()

	// Profit stats
	if s.ProfitStats == nil {
		s.ProfitStats = types.NewProfitStats(s.Market)
	}

	if s.TradeStats == nil {
		s.TradeStats = types.NewTradeStats(s.Symbol)
	}

	s.orderExecutor = bbgo.NewGeneralOrderExecutor(session, s.Symbol, ID, instanceID, s.Position)
	s.orderExecutor.BindEnvironment(s.Environment)
	s.orderExecutor.BindProfitStats(s.ProfitStats)
	s.orderExecutor.BindTradeStats(s.TradeStats)
	s.orderExecutor.Bind()
	s.orderExecutor.TradeCollector().OnPositionUpdate(func(position *types.Position) {
		bbgo.Sync(ctx, s)
	})
	s.ExitMethods.Bind(session, s.orderExecutor)

	// Indicators initialized by StandardIndicatorSet must be initialized in Run()
	// Initialize ReverseEMA
	s.ReverseEMA = s.StandardIndicatorSet.EWMA(s.ReverseEMA.IntervalWindow)
	// Initialize BBs
	s.neutralBoll = s.StandardIndicatorSet.BOLL(s.NeutralBollinger.IntervalWindow, s.NeutralBollinger.BandWidth)

	// Default spread
	if s.Spread == fixedpoint.Zero {
		s.Spread = fixedpoint.NewFromFloat(0.001)
	}

	// StrategyController
	s.Status = types.StrategyStatusRunning
	s.OnSuspend(func() {
		_ = s.orderExecutor.GracefulCancel(ctx)
		bbgo.Sync(ctx, s)
	})
	s.OnEmergencyStop(func() {
		// Close whole position
		_ = s.ClosePosition(ctx, fixedpoint.NewFromFloat(1.0))
	})

	// Initial trend
	session.UserDataStream.OnStart(func() {
		var closePrice fixedpoint.Value
		if !bbgo.IsBackTesting {
			ticker, err := s.session.Exchange.QueryTicker(ctx, s.Symbol)
			if err != nil {
				return
			}

			closePrice = ticker.Buy.Add(ticker.Sell).Div(two)
		} else {
			if price, ok := session.LastPrice(s.Symbol); ok {
				closePrice = price
			}
		}
		priceReverseEMA := fixedpoint.NewFromFloat(s.ReverseEMA.Last(0))

		// Main trend by ReverseEMA
		if closePrice.Compare(priceReverseEMA) > 0 {
			s.mainTrendCurrent = types.DirectionUp
		} else if closePrice.Compare(priceReverseEMA) < 0 {
			s.mainTrendCurrent = types.DirectionDown
		}
	})

	// Check trend reversal
	session.MarketDataStream.OnKLineClosed(types.KLineWith(s.Symbol, s.ReverseInterval, func(kline types.KLine) {
		// closePrice is the close price of current kline
		closePrice := kline.GetClose()
		// priceReverseEMA is the current ReverseEMA price
		priceReverseEMA := fixedpoint.NewFromFloat(s.ReverseEMA.Last(0))

		// Main trend by ReverseEMA
		s.mainTrendPrevious = s.mainTrendCurrent
		if closePrice.Compare(priceReverseEMA) > 0 {
			s.mainTrendCurrent = types.DirectionUp
		} else if closePrice.Compare(priceReverseEMA) < 0 {
			s.mainTrendCurrent = types.DirectionDown
		}
		log.Infof("%s current trend is %v", s.Symbol, s.mainTrendCurrent)

		// Trend reversal
		if s.mainTrendCurrent != s.mainTrendPrevious {
			log.Infof("%s trend reverse to %v", s.Symbol, s.mainTrendCurrent)
			bbgo.Notify("%s trend reverse to %v", s.Symbol, s.mainTrendCurrent)
			// Close on-hand position that is not in the same direction as the new trend
			if !s.Position.IsDust(closePrice) &&
				((s.Position.IsLong() && s.mainTrendCurrent == types.DirectionDown) ||
					(s.Position.IsShort() && s.mainTrendCurrent == types.DirectionUp)) {
				log.Infof("%s closing on-hand position due to trend reverse", s.Symbol)
				bbgo.Notify("%s closing on-hand position due to trend reverse", s.Symbol)
				if err := s.ClosePosition(ctx, fixedpoint.One); err != nil {
					log.WithError(err).Errorf("cannot close on-hand position of %s", s.Symbol)
					bbgo.Notify("cannot close on-hand position of %s", s.Symbol)
				}
			}
		}
	}))

	// Main interval
	session.MarketDataStream.OnKLineClosed(types.KLineWith(s.Symbol, s.Interval, func(kline types.KLine) {
		// StrategyController
		if s.Status != types.StrategyStatusRunning {
			return
		}

		_ = s.orderExecutor.GracefulCancel(ctx)

		// closePrice is the close price of current kline
		closePrice := kline.GetClose()

		// midPrice for ask and bid prices
		var midPrice fixedpoint.Value
		if !bbgo.IsBackTesting {
			ticker, err := s.session.Exchange.QueryTicker(ctx, s.Symbol)
			if err != nil {
				return
			}

			midPrice = ticker.Buy.Add(ticker.Sell).Div(two)
			log.Infof("using ticker price: bid %v / ask %v, mid price %v", ticker.Buy, ticker.Sell, midPrice)
		} else {
			midPrice = closePrice
		}

		// Update price spread
		s.updateSpread()

		// Update max exposure
		s.updateMaxExposure(midPrice)

		// Current position status
		log.Infof("position: %s", s.Position)
		if !s.Position.IsClosed() && !s.Position.IsDust(midPrice) {
			log.Infof("current %s unrealized profit: %f %s", s.Symbol, s.Position.UnrealizedProfit(midPrice).Float64(), s.Market.QuoteCurrency)
		}

		// Order prices
		askPrice, bidPrice := s.getOrderPrices(midPrice)

		// Order qty
		sellQuantity, buyQuantity := s.getOrderQuantities(askPrice, bidPrice)

		buyOrder, sellOrder := s.getOrderForms(buyQuantity, bidPrice, sellQuantity, askPrice)

		canBuy, canSell := s.getCanBuySell(buyQuantity, bidPrice, sellQuantity, askPrice, midPrice)

		// Submit orders
		var submitOrders []types.SubmitOrder
		if canSell && sellOrder.Quantity.Compare(fixedpoint.Zero) > 0 {
			submitOrders = append(submitOrders, sellOrder)
		}
		if canBuy && buyOrder.Quantity.Compare(fixedpoint.Zero) > 0 {
			submitOrders = append(submitOrders, buyOrder)
		}

		if len(submitOrders) == 0 {
			return
		}
		log.Infof("submitting order(s): %v", submitOrders)
		_, _ = s.orderExecutor.SubmitOrders(ctx, submitOrders...)
	}))

	bbgo.OnShutdown(ctx, func(ctx context.Context, wg *sync.WaitGroup) {
		defer wg.Done()

		_ = s.orderExecutor.GracefulCancel(ctx)
	})

	return nil
}