package pivotshort

import (
	"context"
	"fmt"

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

// BreakLow -- when price breaks the previous pivot low, we set a trade entry
type BreakLow struct {
	Symbol string
	Market types.Market
	types.IntervalWindow

	// Ratio is a number less than 1.0, price * ratio will be the price triggers the short order.
	Ratio fixedpoint.Value `json:"ratio"`

	// MarketOrder is the option to enable market order short.
	MarketOrder bool `json:"marketOrder"`

	// BounceRatio is a ratio used for placing the limit order sell price
	// limit sell price = breakLowPrice * (1 + BounceRatio)
	BounceRatio fixedpoint.Value `json:"bounceRatio"`

	Leverage     fixedpoint.Value      `json:"leverage"`
	Quantity     fixedpoint.Value      `json:"quantity"`
	StopEMARange fixedpoint.Value      `json:"stopEMARange"`
	StopEMA      *types.IntervalWindow `json:"stopEMA"`

	TrendEMA *types.IntervalWindow `json:"trendEMA"`

	lastLow  fixedpoint.Value
	pivot    *indicator.Pivot
	stopEWMA *indicator.EWMA

	trendEWMA                       *indicator.EWMA
	trendEWMALast, trendEWMACurrent float64

	pivotLowPrices []fixedpoint.Value

	orderExecutor *bbgo.GeneralOrderExecutor
	session       *bbgo.ExchangeSession
}

func (s *BreakLow) Subscribe(session *bbgo.ExchangeSession) {
	session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.Interval})
	session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: types.Interval1m})

	if s.StopEMA != nil {
		session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.StopEMA.Interval})
	}

	if s.TrendEMA != nil {
		session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.TrendEMA.Interval})
	}
}

func (s *BreakLow) Bind(session *bbgo.ExchangeSession, orderExecutor *bbgo.GeneralOrderExecutor) {
	s.session = session
	s.orderExecutor = orderExecutor

	position := orderExecutor.Position()
	symbol := position.Symbol
	store, _ := session.MarketDataStore(s.Symbol)
	standardIndicator, _ := session.StandardIndicatorSet(s.Symbol)

	s.lastLow = fixedpoint.Zero

	s.pivot = &indicator.Pivot{IntervalWindow: s.IntervalWindow}
	s.pivot.Bind(store)
	preloadPivot(s.pivot, store)

	if s.StopEMA != nil {
		s.stopEWMA = standardIndicator.EWMA(*s.StopEMA)
	}

	if s.TrendEMA != nil {
		s.trendEWMA = standardIndicator.EWMA(*s.TrendEMA)

		session.MarketDataStream.OnKLineClosed(types.KLineWith(s.Symbol, s.TrendEMA.Interval, func(kline types.KLine) {
			s.trendEWMALast = s.trendEWMACurrent
			s.trendEWMACurrent = s.trendEWMA.Last()
		}))
	}

	// update pivot low data
	session.MarketDataStream.OnStart(func() {
		lastLow := fixedpoint.NewFromFloat(s.pivot.LastLow())
		if lastLow.IsZero() {
			return
		}

		if lastLow.Compare(s.lastLow) != 0 {
			bbgo.Notify("%s new pivot low detected: %f", s.Symbol, s.pivot.LastLow())
		}

		s.lastLow = lastLow
		s.pivotLowPrices = append(s.pivotLowPrices, s.lastLow)
	})

	session.MarketDataStream.OnKLineClosed(types.KLineWith(symbol, s.Interval, func(kline types.KLine) {
		lastLow := fixedpoint.NewFromFloat(s.pivot.LastLow())
		if lastLow.IsZero() {
			return
		}

		if lastLow.Compare(s.lastLow) != 0 {
			bbgo.Notify("%s new pivot low detected: %f %s", s.Symbol, s.pivot.LastLow())
		}

		s.lastLow = lastLow
		s.pivotLowPrices = append(s.pivotLowPrices, s.lastLow)
	}))

	session.MarketDataStream.OnKLineClosed(types.KLineWith(symbol, types.Interval1m, func(kline types.KLine) {
		if len(s.pivotLowPrices) == 0 {
			log.Infof("currently there is no pivot low prices, can not check break low...")
			return
		}

		previousLow := s.pivotLowPrices[len(s.pivotLowPrices)-1]
		ratio := fixedpoint.One.Add(s.Ratio)
		breakPrice := previousLow.Mul(ratio)

		openPrice := kline.Open
		closePrice := kline.Close

		// if the previous low is not break, or the kline is not strong enough to break it, skip
		if closePrice.Compare(breakPrice) >= 0 {
			return
		}

		// we need the price cross the break line, or we do nothing:
		// open > break price > close price
		if !(openPrice.Compare(breakPrice) > 0 && closePrice.Compare(breakPrice) < 0) {
			return
		}

		// force direction to be down
		if closePrice.Compare(openPrice) >= 0 {
			log.Infof("%s price %f is closed higher than the open price %f, skip this break", kline.Symbol, closePrice.Float64(), openPrice.Float64())
			// skip UP klines
			return
		}

		log.Infof("%s breakLow signal detected, closed price %f < breakPrice %f", kline.Symbol, closePrice.Float64(), breakPrice.Float64())

		if position.IsOpened(kline.Close) {
			log.Infof("position is already opened, skip short")
			return
		}

		// trend EMA protection
		if s.trendEWMALast > 0.0 && s.trendEWMACurrent > 0.0 {
			slope := s.trendEWMALast / s.trendEWMACurrent
			if slope > 1.0 {
				log.Infof("trendEMA %+v current=%f last=%f slope=%f: skip short", s.TrendEMA, s.trendEWMACurrent, s.trendEWMALast, slope)
				return
			}

			log.Infof("trendEMA %+v current=%f last=%f slope=%f: short is enabled", s.TrendEMA, s.trendEWMACurrent, s.trendEWMALast, slope)
		}

		// stop EMA protection
		if s.stopEWMA != nil {
			ema := fixedpoint.NewFromFloat(s.stopEWMA.Last())
			if ema.IsZero() {
				return
			}

			emaStopShortPrice := ema.Mul(fixedpoint.One.Sub(s.StopEMARange))
			if closePrice.Compare(emaStopShortPrice) < 0 {
				log.Infof("stopEMA protection: close price %f < EMA(%v) = %f", closePrice.Float64(), s.StopEMA, ema.Float64())
				return
			}
		}

		ctx := context.Background()

		// graceful cancel all active orders
		_ = orderExecutor.GracefulCancel(ctx)

		quantity, err := useQuantityOrBaseBalance(s.session, s.Market, closePrice, s.Quantity, s.Leverage)
		if err != nil {
			log.WithError(err).Errorf("quantity calculation error")
		}

		if quantity.IsZero() {
			return
		}

		if s.MarketOrder {
			bbgo.Notify("%s price %f breaks the previous low %f with ratio %f, submitting market sell to open a short position", symbol, kline.Close.Float64(), previousLow.Float64(), s.Ratio.Float64())
			_, _ = s.orderExecutor.SubmitOrders(ctx, types.SubmitOrder{
				Symbol:           s.Symbol,
				Side:             types.SideTypeSell,
				Type:             types.OrderTypeMarket,
				Quantity:         quantity,
				MarginSideEffect: types.SideEffectTypeMarginBuy,
				Tag:              "breakLowMarket",
			})

		} else {
			sellPrice := previousLow.Mul(fixedpoint.One.Add(s.BounceRatio))

			bbgo.Notify("%s price %f breaks the previous low %f with ratio %f, submitting limit sell @ %f", symbol, kline.Close.Float64(), previousLow.Float64(), s.Ratio.Float64(), sellPrice.Float64())
			_, _ = s.orderExecutor.SubmitOrders(ctx, types.SubmitOrder{
				Symbol:           kline.Symbol,
				Side:             types.SideTypeSell,
				Type:             types.OrderTypeLimit,
				Price:            sellPrice,
				Quantity:         quantity,
				MarginSideEffect: types.SideEffectTypeMarginBuy,
				Tag:              "breakLowLimit",
			})
		}
	}))
}

func useQuantityOrBaseBalance(session *bbgo.ExchangeSession, market types.Market, price, quantity, leverage fixedpoint.Value) (fixedpoint.Value, error) {
	usingLeverage := session.Margin || session.IsolatedMargin || session.Futures || session.IsolatedFutures
	if usingLeverage {
		if !quantity.IsZero() {
			return quantity, nil
		}

		if leverage.IsZero() {
			leverage = fixedpoint.NewFromInt(3)
		}

		// quantity is zero, we need to calculate the quantity
		baseBalance, _ := session.Account.Balance(market.BaseCurrency)
		quoteBalance, _ := session.Account.Balance(market.QuoteCurrency)

		// calculate the quantity automatically
		if session.Margin || session.IsolatedMargin {
			baseBalanceValue := baseBalance.Total().Mul(price)
			accountValue := baseBalanceValue.Add(quoteBalance.Total())

			if session.IsolatedMargin {
				originLeverage := leverage
				leverage = fixedpoint.Max(leverage, fixedpoint.NewFromInt(10))
				log.Infof("using isolated margin, maxLeverage=10 originalLeverage=%f currentLeverage=%f",
					originLeverage.Float64(),
					leverage.Float64())
			}

			// spot margin use the equity value, so we use the total quote balance here
			maxPositionQuantity := risk.CalculateMaxPosition(price, accountValue, leverage)

			log.Infof("margin leverage: calculated maxPositionQuantity=%f price=%f accountValue=%f %s leverage=%f",
				maxPositionQuantity.Float64(),
				price.Float64(),
				accountValue.Float64(),
				market.QuoteCurrency,
				leverage.Float64())

			return maxPositionQuantity, nil
		}

		if session.Futures || session.IsolatedFutures {
			// TODO: get mark price here
			maxPositionQuantity := risk.CalculateMaxPosition(price, quoteBalance.Available, leverage)
			requiredPositionCost := risk.CalculatePositionCost(price, price, maxPositionQuantity, leverage, types.SideTypeSell)
			if quoteBalance.Available.Compare(requiredPositionCost) < 0 {
				return maxPositionQuantity, fmt.Errorf("available margin %f %s is not enough, can not submit order", quoteBalance.Available.Float64(), market.QuoteCurrency)
			}

			return maxPositionQuantity, nil
		}

	}

	// For spot, we simply sell the base currency
	balance, hasBalance := session.Account.Balance(market.BaseCurrency)
	if hasBalance {
		if quantity.IsZero() {
			log.Warnf("sell quantity is not set, submitting sell with all base balance: %s", balance.Available.String())
			if !balance.Available.IsZero() {
				return balance.Available, nil
			}
		} else {
			return fixedpoint.Min(quantity, balance.Available), nil
		}
	}

	return quantity, fmt.Errorf("quantity is zero, can not submit sell order, please check your settings")
}