package mirrormaker

import (
	"context"
	"fmt"
	"sync"
	"time"

	"github.com/sirupsen/logrus"

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

const ID = "mirrormaker"

var defaultMargin = fixedpoint.NewFromFloat(0.01)

var defaultQuantity = fixedpoint.NewFromFloat(0.001)

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

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

type Strategy struct {
	*bbgo.Graceful
	*bbgo.Persistence

	Symbol         string `json:"symbol"`
	SourceExchange string `json:"sourceExchange"`
	MakerExchange  string `json:"makerExchange"`

	UpdateInterval     time.Duration    `json:"updateInterval"`
	Margin             fixedpoint.Value `json:"margin"`
	BidMargin          fixedpoint.Value `json:"bidMargin"`
	AskMargin          fixedpoint.Value `json:"askMargin"`
	Quantity           fixedpoint.Value `json:"quantity"`
	QuantityMultiplier fixedpoint.Value `json:"quantityMultiplier"`

	NumLayers int `json:"numLayers"`
	Pips      int `json:"pips"`

	makerSession  *bbgo.ExchangeSession
	sourceSession *bbgo.ExchangeSession

	sourceMarket types.Market
	makerMarket  types.Market

	book              *types.StreamOrderBook
	activeMakerOrders *bbgo.LocalActiveOrderBook

	orderStore *bbgo.OrderStore

	Position  fixedpoint.Value
	lastPrice float64

	stopC chan struct{}
}

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

func (s *Strategy) CrossSubscribe(sessions map[string]*bbgo.ExchangeSession) {
	sourceSession, ok := sessions[s.SourceExchange]
	if !ok {
		panic(fmt.Errorf("source exchange %s is not defined", s.SourceExchange))
	}

	log.Infof("subscribing %s from %s", s.Symbol, s.SourceExchange)
	sourceSession.Subscribe(types.BookChannel, s.Symbol, types.SubscribeOptions{})
}

func (s *Strategy) updateQuote(ctx context.Context) {
	if err := s.makerSession.Exchange.CancelOrders(ctx, s.activeMakerOrders.Orders()...); err != nil {
		log.WithError(err).Errorf("can not cancel orders")
		return
	}

	// avoid unlock issue
	time.Sleep(100 * time.Millisecond)

	sourceBook := s.book.Get()
	if len(sourceBook.Bids) == 0 || len(sourceBook.Asks) == 0 {
		return
	}

	bestBidPrice := sourceBook.Bids[0].Price
	bestAskPrice := sourceBook.Asks[0].Price
	log.Infof("best bid price %f, best ask price: %f", bestBidPrice.Float64(), bestAskPrice.Float64())

	bidQuantity := s.Quantity
	bidPrice := bestBidPrice.MulFloat64(1.0 - s.BidMargin.Float64())

	askQuantity := s.Quantity
	askPrice := bestAskPrice.MulFloat64(1.0 + s.AskMargin.Float64())

	log.Infof("quote bid price: %f ask price: %f", bidPrice.Float64(), askPrice.Float64())

	var submitOrders []types.SubmitOrder

	balances := s.makerSession.Account.Balances()
	makerQuota := &bbgo.QuotaTransaction{}
	if b, ok := balances[s.makerMarket.BaseCurrency]; ok {
		makerQuota.BaseAsset.Add(b.Available)
	}
	if b, ok := balances[s.makerMarket.QuoteCurrency]; ok {
		makerQuota.QuoteAsset.Add(b.Available)
	}

	hedgeBalances := s.sourceSession.Account.Balances()
	hedgeQuota := &bbgo.QuotaTransaction{}
	if b, ok := hedgeBalances[s.sourceMarket.BaseCurrency]; ok {
		hedgeQuota.BaseAsset.Add(b.Available)
	}
	if b, ok := hedgeBalances[s.sourceMarket.QuoteCurrency]; ok {
		hedgeQuota.QuoteAsset.Add(b.Available)
	}

	log.Infof("maker quota: %+v", makerQuota)
	log.Infof("hedge quota: %+v", hedgeQuota)

	for i := 0; i < s.NumLayers; i++ {
		// bid orders
		if makerQuota.QuoteAsset.Lock(bidQuantity.Mul(bidPrice)) && hedgeQuota.BaseAsset.Lock(bidQuantity) {
			// if we bought, then we need to sell the base from the hedge session
			submitOrders = append(submitOrders, types.SubmitOrder{
				Symbol:      s.Symbol,
				Type:        types.OrderTypeLimit,
				Side:        types.SideTypeBuy,
				Price:       bidPrice.Float64(),
				Quantity:    bidQuantity.Float64(),
				TimeInForce: "GTC",
			})

			makerQuota.Commit()
			hedgeQuota.Commit()
		} else {
			makerQuota.Rollback()
			hedgeQuota.Rollback()
		}

		// ask orders
		if makerQuota.BaseAsset.Lock(askQuantity) && hedgeQuota.QuoteAsset.Lock(askQuantity.Mul(askPrice)) {
			// if we bought, then we need to sell the base from the hedge session
			submitOrders = append(submitOrders, types.SubmitOrder{
				Symbol:      s.Symbol,
				Type:        types.OrderTypeLimit,
				Side:        types.SideTypeSell,
				Price:       askPrice.Float64(),
				Quantity:    askQuantity.Float64(),
				TimeInForce: "GTC",
			})
			makerQuota.Commit()
			hedgeQuota.Commit()
		} else {
			makerQuota.Rollback()
			hedgeQuota.Rollback()
		}

		bidPrice -= fixedpoint.NewFromFloat(s.makerMarket.TickSize * float64(s.Pips))
		askPrice += fixedpoint.NewFromFloat(s.makerMarket.TickSize * float64(s.Pips))

		askQuantity = askQuantity.Mul(s.QuantityMultiplier)
		bidQuantity = bidQuantity.Mul(s.QuantityMultiplier)
	}

	if len(submitOrders) == 0 {
		return
	}

	makerOrderExecutor := &bbgo.ExchangeOrderExecutor{Session: s.makerSession}
	makerOrders, err := makerOrderExecutor.SubmitOrders(ctx, submitOrders...)
	if err != nil {
		log.WithError(err).Errorf("order submit error")
		return
	}

	s.activeMakerOrders.Add(makerOrders...)
	s.orderStore.Add(makerOrders...)
}

func (s *Strategy) handleTradeUpdate(trade types.Trade) {
	log.Infof("received trade %+v", trade)
	if s.orderStore.Exists(trade.OrderID) {
		log.Infof("identified trade %d with an existing order: %d", trade.ID, trade.OrderID)

		q := fixedpoint.NewFromFloat(trade.Quantity)
		if trade.Side == types.SideTypeSell {
			q = -q
		}

		s.Position.AtomicAdd(q)

		pos := s.Position.AtomicLoad()
		log.Warnf("position changed: %f", pos.Float64())

		s.lastPrice = trade.Price
	}
}

func (s *Strategy) CrossRun(ctx context.Context, _ bbgo.OrderExecutionRouter, sessions map[string]*bbgo.ExchangeSession) error {
	if s.UpdateInterval == 0 {
		s.UpdateInterval = time.Second
	}

	if s.NumLayers == 0 {
		s.NumLayers = 1
	}

	if s.BidMargin == 0 {
		if s.Margin != 0 {
			s.BidMargin = s.Margin
		} else {
			s.BidMargin = defaultMargin
		}
	}

	if s.AskMargin == 0 {
		if s.Margin != 0 {
			s.AskMargin = s.Margin
		} else {
			s.AskMargin = defaultMargin
		}
	}

	if s.Quantity == 0 {
		s.Quantity = defaultQuantity
	}

	sourceSession, ok := sessions[s.SourceExchange]
	if !ok {
		return fmt.Errorf("source exchange session %s is not defined", s.SourceExchange)
	}

	s.sourceSession = sourceSession

	makerSession, ok := sessions[s.MakerExchange]
	if !ok {
		return fmt.Errorf("maker exchange session %s is not defined", s.MakerExchange)
	}

	s.makerSession = makerSession

	s.sourceMarket, ok = s.sourceSession.Market(s.Symbol)
	if !ok {
		return fmt.Errorf("source session market %s is not defined", s.Symbol)
	}

	s.makerMarket, ok = s.makerSession.Market(s.Symbol)
	if !ok {
		return fmt.Errorf("maker session market %s is not defined", s.Symbol)
	}

	s.book = types.NewStreamBook(s.Symbol)
	s.book.BindStream(s.sourceSession.Stream)

	s.makerSession.Stream.OnTradeUpdate(s.handleTradeUpdate)

	s.activeMakerOrders = bbgo.NewLocalActiveOrderBook()
	s.activeMakerOrders.BindStream(s.makerSession.Stream)

	s.orderStore = bbgo.NewOrderStore(s.Symbol)
	s.orderStore.BindStream(s.makerSession.Stream)

	s.stopC = make(chan struct{})

	if err := s.Persistence.Load(&s.Position, "position"); err != nil {
		log.WithError(err).Warnf("can not load position")
	} else {
		log.Infof("position is loaded successfully, position=%f", s.Position.Float64())
	}

	go func() {
		ticker := time.NewTicker(s.UpdateInterval)
		defer ticker.Stop()
		for {
			select {

			case <-s.stopC:
				return

			case <-ctx.Done():
				return

			case <-ticker.C:
				s.updateQuote(ctx)
			}
		}
	}()

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

		close(s.stopC)

		if err := s.Persistence.Save(&s.Position, "position"); err != nil {
			log.WithError(err).Error("persistence save error")
		}

		if err := s.makerSession.Exchange.CancelOrders(ctx, s.activeMakerOrders.Orders()...); err != nil {
			log.WithError(err).Errorf("can not cancel orders")
		}
	})

	return nil
}