package bbgo

import (
	"context"
	"fmt"

	log "github.com/sirupsen/logrus"

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

type HigherHighLowerLowStop struct {
	Symbol string `json:"symbol"`

	// Interval is the kline interval used by this exit. Window is used as the range to determining higher highs and
	// lower lows
	types.IntervalWindow

	// HighLowWindow is the range to calculate the number of higher highs and lower lows
	HighLowWindow int `json:"highLowWindow"`

	// If the number of higher highs or lower lows with in HighLowWindow is more than MaxHighLow, the exit is triggered.
	// 0 disables this parameter. Either one of MaxHighLow and MinHighLow must be larger than 0
	MaxHighLow int `json:"maxHighLow"`

	// If the number of higher highs or lower lows with in HighLowWindow is less than MinHighLow, the exit is triggered.
	// 0 disables this parameter. Either one of MaxHighLow and MinHighLow must be larger than 0
	MinHighLow int `json:"minHighLow"`

	// ActivationRatio is the trigger condition
	// When the price goes higher (lower for short position) than this ratio, the stop will be activated.
	// You can use this to combine several exits
	ActivationRatio fixedpoint.Value `json:"activationRatio"`

	// DeactivationRatio is the kill condition
	// When the price goes higher (lower for short position) than this ratio, the stop will be deactivated.
	// You can use this to combine several exits
	DeactivationRatio fixedpoint.Value `json:"deactivationRatio"`

	// If true, looking for lower lows in long position and higher highs in short position. If false, looking for higher
	// highs in long position and lower lows in short position
	OppositeDirectionAsPosition bool `json:"oppositeDirectionAsPosition"`

	klines types.KLineWindow

	// activated: when the price reaches the min profit price, we set the activated to true to enable hhll stop
	activated bool

	highLows []types.Direction

	session       *ExchangeSession
	orderExecutor *GeneralOrderExecutor
}

// Subscribe required k-line stream
func (s *HigherHighLowerLowStop) Subscribe(session *ExchangeSession) {
	session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.Interval})
}

// updateActivated checks the position cost against the close price, activation ratio, and deactivation ratio to
// determine whether this stop should be activated
func (s *HigherHighLowerLowStop) updateActivated(position *types.Position, closePrice fixedpoint.Value) {
	// deactivate when no position
	if position.IsClosed() || position.IsDust(closePrice) {

		s.activated = false
		return

	}

	// activation/deactivation price
	var priceDeactive fixedpoint.Value
	var priceActive fixedpoint.Value
	if position.IsLong() {
		priceDeactive = position.AverageCost.Mul(fixedpoint.One.Add(s.DeactivationRatio))
		priceActive = position.AverageCost.Mul(fixedpoint.One.Add(s.ActivationRatio))
	} else {
		priceDeactive = position.AverageCost.Mul(fixedpoint.One.Sub(s.DeactivationRatio))
		priceActive = position.AverageCost.Mul(fixedpoint.One.Sub(s.ActivationRatio))
	}

	if s.activated {

		if position.IsLong() {

			if closePrice.Compare(priceDeactive) >= 0 {

				s.activated = false
				Notify("[hhllStop] Stop of %s deactivated for long position, deactivation ratio %s", s.Symbol, s.DeactivationRatio.Percentage())

			} else if closePrice.Compare(priceActive) < 0 {

				s.activated = false
				Notify("[hhllStop] Stop of %s deactivated for long position, activation ratio %s", s.Symbol, s.ActivationRatio.Percentage())

			}

		} else if position.IsShort() {

			// for short position, if the close price is less than the activation price then this is a profit position.
			if closePrice.Compare(priceDeactive) <= 0 {

				s.activated = false
				Notify("[hhllStop] Stop of %s deactivated for short position, deactivation ratio %s", s.Symbol, s.DeactivationRatio.Percentage())

			} else if closePrice.Compare(priceActive) > 0 {

				s.activated = false
				Notify("[hhllStop] Stop of %s deactivated for short position, activation ratio %s", s.Symbol, s.ActivationRatio.Percentage())

			}

		}
	} else {

		if position.IsLong() {

			if closePrice.Compare(priceActive) >= 0 && closePrice.Compare(priceDeactive) < 0 {

				s.activated = true
				Notify("[hhllStop] %s stop is activated for long position, activation ratio %s, deactivation ratio %s", s.Symbol, s.ActivationRatio.Percentage(), s.DeactivationRatio.Percentage())

			}

		} else if position.IsShort() {

			// for short position, if the close price is less than the activation price then this is a profit position.
			if closePrice.Compare(priceActive) <= 0 && closePrice.Compare(priceDeactive) > 0 {

				s.activated = true
				Notify("[hhllStop] %s stop is activated for short position, activation ratio %s, deactivation ratio %s", s.Symbol, s.ActivationRatio.Percentage(), s.DeactivationRatio.Percentage())

			}

		}

	}
}

func (s *HigherHighLowerLowStop) updateHighLowNumber(kline types.KLine) {
	s.klines.Truncate(s.Window - 1)

	if s.klines.Len() >= s.Window-1 {
		high := kline.GetHigh()
		low := kline.GetLow()
		if s.klines.GetHigh().Compare(high) < 0 {
			s.highLows = append(s.highLows, types.DirectionUp)
			log.Debugf("[hhllStop] detected %s new higher high %f", s.Symbol, high.Float64())
		} else if s.klines.GetLow().Compare(low) > 0 {
			s.highLows = append(s.highLows, types.DirectionDown)
			log.Debugf("[hhllStop] detected %s new lower low %f", s.Symbol, low.Float64())
		} else {
			s.highLows = append(s.highLows, types.DirectionNone)
		}

		// Truncate highLows
		if len(s.highLows) > s.HighLowWindow {
			end := len(s.highLows)
			start := end - s.HighLowWindow
			if start < 0 {
				start = 0
			}
			kn := s.highLows[start:]
			s.highLows = kn
		}

	} else {
		s.highLows = append(s.highLows, types.DirectionNone)
	}

	s.klines.Add(kline)
}

func (s *HigherHighLowerLowStop) shouldStop(position *types.Position) bool {
	if s.klines.Len() < s.Window || len(s.highLows) < s.HighLowWindow {
		log.Debugf("[hhllStop] not enough data for %s yet", s.Symbol)
		return false
	}

	if s.activated {
		highs := 0
		lows := 0
		for _, hl := range s.highLows {
			switch hl {
			case types.DirectionUp:
				highs++
			case types.DirectionDown:
				lows++
			}
		}

		log.Debugf("[hhllStop] %d higher highs and %d lower lows in window of %d", highs, lows, s.HighLowWindow)

		// Check higher highs
		if (position.IsLong() && !s.OppositeDirectionAsPosition) || (position.IsShort() && s.OppositeDirectionAsPosition) {
			if (s.MinHighLow > 0 && highs < s.MinHighLow) || (s.MaxHighLow > 0 && highs > s.MaxHighLow) {
				return true
			}
			// Check lower lows
		} else if (position.IsShort() && !s.OppositeDirectionAsPosition) || (position.IsLong() && s.OppositeDirectionAsPosition) {
			if (s.MinHighLow > 0 && lows < s.MinHighLow) || (s.MaxHighLow > 0 && lows > s.MaxHighLow) {
				return true
			}
		}
	}
	return false
}

func (s *HigherHighLowerLowStop) Bind(session *ExchangeSession, orderExecutor *GeneralOrderExecutor) {
	// Check parameters
	if s.Window <= 0 {
		panic(fmt.Errorf("[hhllStop] window must be larger than zero"))
	}
	if s.HighLowWindow <= 0 {
		panic(fmt.Errorf("[hhllStop] highLowWindow must be larger than zero"))
	}
	if s.MaxHighLow <= 0 && s.MinHighLow <= 0 {
		panic(fmt.Errorf("[hhllStop] either maxHighLow or minHighLow must be larger than zero"))
	}

	s.session = session
	s.orderExecutor = orderExecutor

	position := orderExecutor.Position()
	session.MarketDataStream.OnKLineClosed(types.KLineWith(s.Symbol, s.Interval, func(kline types.KLine) {
		s.updateActivated(position, kline.GetClose())

		s.updateHighLowNumber(kline)

		// Close position & reset
		if s.shouldStop(position) {
			defer func() {
				s.activated = false
			}()

			err := s.orderExecutor.ClosePosition(context.Background(), fixedpoint.One, "hhllStop")
			if err != nil {
				Notify("[hhllStop] Stop of %s triggered but failed to close %s position:", s.Symbol, err)
				return
			}

			Notify("[hhllStop] Stop of %s triggered and position closed", s.Symbol)
		}
	}))

	// Make sure the stop is reset when position is closed or dust
	orderExecutor.TradeCollector().OnPositionUpdate(func(position *types.Position) {
		if position.IsClosed() || position.IsDust(position.AverageCost) {
			s.activated = false
		}
	})
}