bbgo_origin/pkg/strategy/ewoDgtrd/strategy.go

package ewoDgtrd

import (
	"context"
	"errors"
	"fmt"
	"math"
	"os"
	"sync"

	"github.com/fatih/color"
	"github.com/sirupsen/logrus"

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

const ID = "ewo_dgtrd"

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

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

type Strategy struct {
	Position    *types.Position    `json:"position,omitempty" persistence:"position"`
	ProfitStats *types.ProfitStats `json:"profitStats,omitempty" persistence:"profit_stats"`

	Market              types.Market
	Session             *bbgo.ExchangeSession
	UseHeikinAshi       bool             `json:"useHeikinAshi"` // use heikinashi kline
	Stoploss            fixedpoint.Value `json:"stoploss"`
	Symbol              string           `json:"symbol"`
	Interval            types.Interval   `json:"interval"`
	UseEma              bool             `json:"useEma"`              // use exponential ma or not
	UseSma              bool             `json:"useSma"`              // if UseEma == false, use simple ma or not
	SignalWindow        int              `json:"sigWin"`              // signal window
	DisableShortStop    bool             `json:"disableShortStop"`    // disable SL on short
	DisableLongStop     bool             `json:"disableLongStop"`     // disable SL on long
	FilterHigh          float64          `json:"cciStochFilterHigh"`  // high filter for CCI Stochastic indicator
	FilterLow           float64          `json:"cciStochFilterLow"`   // low filter for CCI Stochastic indicator
	EwoChangeFilterHigh float64          `json:"ewoChangeFilterHigh"` // high filter for ewo histogram
	EwoChangeFilterLow  float64          `json:"ewoChangeFilterLow"`  // low filter for ewo histogram

	Record bool `json:"record"` // print record messages on position exit point

	KLineStartTime types.Time
	KLineEndTime   types.Time

	*bbgo.Environment
	*bbgo.Graceful
	bbgo.StrategyController

	activeMakerOrders *bbgo.ActiveOrderBook
	orderStore        *bbgo.OrderStore
	tradeCollector    *bbgo.TradeCollector
	entryPrice        fixedpoint.Value
	waitForTrade      bool

	atr           *indicator.ATR
	emv           *indicator.EMV
	ccis          *CCISTOCH
	ma5           types.Series
	ma34          types.Series
	ewo           types.Series
	ewoSignal     types.Series
	ewoHistogram  types.Series
	ewoChangeRate float64
	heikinAshi    *HeikinAshi
	peakPrice     fixedpoint.Value
	bottomPrice   fixedpoint.Value
	midPrice      fixedpoint.Value
	lock          sync.RWMutex

	buyPrice  fixedpoint.Value
	sellPrice fixedpoint.Value
}

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

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

func (s *Strategy) Initialize() error {
	return nil
}

func (s *Strategy) Subscribe(session *bbgo.ExchangeSession) {
	log.Infof("subscribe %s", s.Symbol)
	session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: types.Interval1m})
	session.Subscribe(types.KLineChannel, s.Symbol, types.SubscribeOptions{Interval: s.Interval})

	session.Subscribe(types.BookTickerChannel, s.Symbol, types.SubscribeOptions{})
}

type UpdatableSeries interface {
	types.Series
	Update(value float64)
}

// Refer: https://tw.tradingview.com/script/XZyG5SOx-CCI-Stochastic-and-a-quick-lesson-on-Scalping-Trading-Systems/
type CCISTOCH struct {
	cci        *indicator.CCI
	stoch      *indicator.STOCH
	ma         *indicator.SMA
	filterHigh float64
	filterLow  float64
}

func NewCCISTOCH(i types.Interval, filterHigh, filterLow float64) *CCISTOCH {
	cci := &indicator.CCI{IntervalWindow: types.IntervalWindow{Interval: i, Window: 28}}
	stoch := &indicator.STOCH{IntervalWindow: types.IntervalWindow{Interval: i, Window: 28}}
	ma := &indicator.SMA{IntervalWindow: types.IntervalWindow{Interval: i, Window: 3}}
	return &CCISTOCH{
		cci:        cci,
		stoch:      stoch,
		ma:         ma,
		filterHigh: filterHigh,
		filterLow:  filterLow,
	}
}

func (inc *CCISTOCH) Update(cloze float64) {
	inc.cci.Update(cloze)
	inc.stoch.Update(inc.cci.Last(), inc.cci.Last(), inc.cci.Last())
	inc.ma.Update(inc.stoch.LastD())
}

func (inc *CCISTOCH) BuySignal() bool {
	hasGrey := false
	for i := 0; i < len(inc.ma.Values); i++ {
		v := inc.ma.Index(i)
		if v > inc.filterHigh {
			return false
		} else if v >= inc.filterLow && v <= inc.filterHigh {
			hasGrey = true
			continue
		} else if v < inc.filterLow {
			return hasGrey
		}
	}
	return false
}

func (inc *CCISTOCH) SellSignal() bool {
	hasGrey := false
	for i := 0; i < len(inc.ma.Values); i++ {
		v := inc.ma.Index(i)
		if v < inc.filterLow {
			return false
		} else if v >= inc.filterLow && v <= inc.filterHigh {
			hasGrey = true
			continue
		} else if v > inc.filterHigh {
			return hasGrey
		}
	}
	return false
}

type VWEMA struct {
	PV UpdatableSeries
	V  UpdatableSeries
}

func (inc *VWEMA) Last() float64 {
	return inc.PV.Last() / inc.V.Last()
}

func (inc *VWEMA) Index(i int) float64 {
	if i >= inc.PV.Length() {
		return 0
	}
	vi := inc.V.Index(i)
	if vi == 0 {
		return 0
	}
	return inc.PV.Index(i) / vi
}

func (inc *VWEMA) Length() int {
	pvl := inc.PV.Length()
	vl := inc.V.Length()
	if pvl < vl {
		return pvl
	}
	return vl
}

func (inc *VWEMA) Update(kline types.KLine) {
	inc.PV.Update(kline.Close.Mul(kline.Volume).Float64())
	inc.V.Update(kline.Volume.Float64())
}

func (inc *VWEMA) UpdateVal(price float64, vol float64) {
	inc.PV.Update(price * vol)
	inc.V.Update(vol)
}

// Setup the Indicators going to be used
func (s *Strategy) SetupIndicators(store *bbgo.MarketDataStore) {
	window5 := types.IntervalWindow{Interval: s.Interval, Window: 5}
	window34 := types.IntervalWindow{Interval: s.Interval, Window: 34}
	s.atr = &indicator.ATR{IntervalWindow: window34}
	s.emv = &indicator.EMV{IntervalWindow: types.IntervalWindow{Interval: s.Interval, Window: 14}}
	s.ccis = NewCCISTOCH(s.Interval, s.FilterHigh, s.FilterLow)

	getSource := func(window types.KLineWindow) types.Series {
		if s.UseHeikinAshi {
			return s.heikinAshi.Close
		}
		return window.Close()
	}
	getVol := func(window types.KLineWindow) types.Series {
		if s.UseHeikinAshi {
			return s.heikinAshi.Volume
		}
		return window.Volume()
	}
	s.heikinAshi = NewHeikinAshi(500)
	store.OnKLineWindowUpdate(func(interval types.Interval, window types.KLineWindow) {
		if interval == s.atr.Interval {
			if s.atr.RMA == nil {
				for _, kline := range window {
					high := kline.High.Float64()
					low := kline.Low.Float64()
					cloze := kline.Close.Float64()
					vol := kline.Volume.Float64()
					s.atr.Update(high, low, cloze)
					s.emv.Update(high, low, vol)
				}
			} else {
				kline := window[len(window)-1]
				high := kline.High.Float64()
				low := kline.Low.Float64()
				cloze := kline.Close.Float64()
				vol := kline.Volume.Float64()
				s.atr.Update(high, low, cloze)
				s.emv.Update(high, low, vol)
			}
		}
		if s.Interval != interval {
			return
		}
		if s.heikinAshi.Close.Length() == 0 {
			for _, kline := range window {
				s.heikinAshi.Update(kline)
				s.ccis.Update(getSource(window).Last())
			}
		} else {
			s.heikinAshi.Update(window[len(window)-1])
			s.ccis.Update(getSource(window).Last())
		}
	})
	if s.UseEma {
		ema5 := &indicator.EWMA{IntervalWindow: window5}
		ema34 := &indicator.EWMA{IntervalWindow: window34}
		store.OnKLineWindowUpdate(func(interval types.Interval, window types.KLineWindow) {
			if s.Interval != interval {
				return
			}
			if ema5.Length() == 0 {
				closes := types.Reverse(getSource(window))
				for _, cloze := range closes {
					ema5.Update(cloze)
					ema34.Update(cloze)
				}
			} else {
				cloze := getSource(window).Last()
				ema5.Update(cloze)
				ema34.Update(cloze)
			}

		})

		s.ma5 = ema5
		s.ma34 = ema34
	} else if s.UseSma {
		sma5 := &indicator.SMA{IntervalWindow: window5}
		sma34 := &indicator.SMA{IntervalWindow: window34}
		store.OnKLineWindowUpdate(func(interval types.Interval, window types.KLineWindow) {
			if s.Interval != interval {
				return
			}
			if sma5.Length() == 0 {
				closes := types.Reverse(getSource(window))
				for _, cloze := range closes {
					sma5.Update(cloze)
					sma34.Update(cloze)
				}
			} else {
				cloze := getSource(window).Last()
				sma5.Update(cloze)
				sma34.Update(cloze)
			}
		})
		s.ma5 = sma5
		s.ma34 = sma34
	} else {
		evwma5 := &VWEMA{
			PV: &indicator.EWMA{IntervalWindow: window5},
			V:  &indicator.EWMA{IntervalWindow: window5},
		}
		evwma34 := &VWEMA{
			PV: &indicator.EWMA{IntervalWindow: window34},
			V:  &indicator.EWMA{IntervalWindow: window34},
		}
		store.OnKLineWindowUpdate(func(interval types.Interval, window types.KLineWindow) {
			if s.Interval != interval {
				return
			}
			clozes := getSource(window)
			vols := getVol(window)
			if evwma5.PV.Length() == 0 {
				for i := clozes.Length() - 1; i >= 0; i-- {
					price := clozes.Index(i)
					vol := vols.Index(i)
					evwma5.UpdateVal(price, vol)
					evwma34.UpdateVal(price, vol)
				}
			} else {
				price := clozes.Last()
				vol := vols.Last()
				evwma5.UpdateVal(price, vol)
				evwma34.UpdateVal(price, vol)
			}
		})
		s.ma5 = evwma5
		s.ma34 = evwma34
	}

	s.ewo = types.Mul(types.Minus(types.Div(s.ma5, s.ma34), 1.0), 100.)
	s.ewoHistogram = types.Minus(s.ma5, s.ma34)
	windowSignal := types.IntervalWindow{Interval: s.Interval, Window: s.SignalWindow}
	if s.UseEma {
		sig := &indicator.EWMA{IntervalWindow: windowSignal}
		store.OnKLineWindowUpdate(func(interval types.Interval, _ types.KLineWindow) {
			if interval != s.Interval {
				return
			}

			if sig.Length() == 0 {
				// lazy init
				ewoVals := types.Reverse(s.ewo)
				for _, ewoValue := range ewoVals {
					sig.Update(ewoValue)
				}
			} else {
				sig.Update(s.ewo.Last())
			}
		})
		s.ewoSignal = sig
	} else if s.UseSma {
		sig := &indicator.SMA{IntervalWindow: windowSignal}
		store.OnKLineWindowUpdate(func(interval types.Interval, _ types.KLineWindow) {
			if interval != s.Interval {
				return
			}

			if sig.Length() == 0 {
				// lazy init
				ewoVals := types.Reverse(s.ewo)
				for _, ewoValue := range ewoVals {
					sig.Update(ewoValue)
				}
			} else {
				sig.Update(s.ewo.Last())
			}
		})
		s.ewoSignal = sig
	} else {
		sig := &VWEMA{
			PV: &indicator.EWMA{IntervalWindow: windowSignal},
			V:  &indicator.EWMA{IntervalWindow: windowSignal},
		}
		store.OnKLineWindowUpdate(func(interval types.Interval, window types.KLineWindow) {
			if interval != s.Interval {
				return
			}
			if sig.Length() == 0 {
				// lazy init
				ewoVals := types.Reverse(s.ewo)
				for i, ewoValue := range ewoVals {
					vol := window.Volume().Index(i)
					sig.PV.Update(ewoValue * vol)
					sig.V.Update(vol)
				}
			} else {
				vol := window.Volume().Last()
				sig.PV.Update(s.ewo.Last() * vol)
				sig.V.Update(vol)
			}
		})
		s.ewoSignal = sig
	}
}

// Utility to evaluate if the order is valid or not to send to the exchange
func (s *Strategy) validateOrder(order *types.SubmitOrder) error {
	if order.Type == types.OrderTypeMarket && order.TimeInForce != "" {
		return errors.New("wrong field: market vs TimeInForce")
	}
	if order.Side == types.SideTypeSell {
		baseBalance, ok := s.Session.GetAccount().Balance(s.Market.BaseCurrency)
		if !ok {
			log.Error("cannot get account")
			return errors.New("cannot get account")
		}
		if order.Quantity.Compare(baseBalance.Available) > 0 {
			log.Errorf("qty %v > avail %v", order.Quantity, baseBalance.Available)
			return errors.New("qty > avail")
		}
		price := order.Price
		if price.IsZero() {
			price, ok = s.Session.LastPrice(s.Symbol)
			if !ok {
				log.Error("no price")
				return errors.New("no price")
			}
		}
		orderAmount := order.Quantity.Mul(price)
		if order.Quantity.Sign() <= 0 ||
			order.Quantity.Compare(s.Market.MinQuantity) < 0 ||
			orderAmount.Compare(s.Market.MinNotional) < 0 {
			log.Debug("amount fail")
			return fmt.Errorf("amount fail: quantity: %v, amount: %v", order.Quantity, orderAmount)
		}
		return nil
	} else if order.Side == types.SideTypeBuy {
		quoteBalance, ok := s.Session.GetAccount().Balance(s.Market.QuoteCurrency)
		if !ok {
			log.Error("cannot get account")
			return errors.New("cannot get account")
		}
		price := order.Price
		if price.IsZero() {
			price, ok = s.Session.LastPrice(s.Symbol)
			if !ok {
				log.Error("no price")
				return errors.New("no price")
			}
		}
		totalQuantity := quoteBalance.Available.Div(price)
		if order.Quantity.Compare(totalQuantity) > 0 {
			log.Errorf("qty %v > avail %v", order.Quantity, totalQuantity)
			return errors.New("qty > avail")
		}
		orderAmount := order.Quantity.Mul(price)
		if order.Quantity.Sign() <= 0 ||
			orderAmount.Compare(s.Market.MinNotional) < 0 ||
			order.Quantity.Compare(s.Market.MinQuantity) < 0 {
			log.Debug("amount fail")
			return fmt.Errorf("amount fail: quantity: %v, amount: %v", order.Quantity, orderAmount)
		}
		return nil
	}
	log.Error("side error")
	return errors.New("side error")

}

func (s *Strategy) PlaceBuyOrder(ctx context.Context, price fixedpoint.Value) (*types.Order, *types.Order) {
	var closeOrder *types.Order
	var ok bool
	waitForTrade := false
	base := s.Position.GetBase()
	if base.Abs().Compare(s.Market.MinQuantity) >= 0 && base.Mul(s.GetLastPrice()).Abs().Compare(s.Market.MinNotional) >= 0 && base.Sign() < 0 {
		if closeOrder, ok = s.ClosePosition(ctx); !ok {
			log.Errorf("sell position %v remained not closed, skip placing order", base)
			return closeOrder, nil
		}
	}
	if s.Position.GetBase().Sign() < 0 {
		// we are not able to make close trade at this moment,
		// will close the rest of the position by normal limit order
		// s.entryPrice is set in the last trade
		waitForTrade = true
	}
	quoteBalance, ok := s.Session.GetAccount().Balance(s.Market.QuoteCurrency)
	if !ok {
		log.Infof("buy order at price %v failed", price)
		return closeOrder, nil
	}
	quantityAmount := quoteBalance.Available
	totalQuantity := quantityAmount.Div(price)
	order := types.SubmitOrder{
		Symbol:      s.Symbol,
		Side:        types.SideTypeBuy,
		Type:        types.OrderTypeLimit,
		Price:       price,
		Quantity:    totalQuantity,
		Market:      s.Market,
		TimeInForce: types.TimeInForceGTC,
	}
	if err := s.validateOrder(&order); err != nil {
		log.Infof("validation failed %v: %v", order, err)
		return closeOrder, nil
	}
	log.Warnf("long at %v, position %v, closeOrder %v, timestamp: %s", price, s.Position.GetBase(), closeOrder, s.KLineStartTime)
	createdOrders, err := s.Session.Exchange.SubmitOrders(ctx, order)
	if err != nil {
		log.WithError(err).Errorf("cannot place order")
		return closeOrder, nil
	}

	log.Infof("post order c: %v, entryPrice: %v o: %v", waitForTrade, s.entryPrice, createdOrders)
	s.waitForTrade = waitForTrade
	s.orderStore.Add(createdOrders...)
	s.activeMakerOrders.Add(createdOrders...)
	s.tradeCollector.Process()
	return closeOrder, &createdOrders[0]
}

func (s *Strategy) PlaceSellOrder(ctx context.Context, price fixedpoint.Value) (*types.Order, *types.Order) {
	var closeOrder *types.Order
	var ok bool
	waitForTrade := false
	base := s.Position.GetBase()
	if base.Abs().Compare(s.Market.MinQuantity) >= 0 && base.Abs().Mul(s.GetLastPrice()).Compare(s.Market.MinNotional) >= 0 && base.Sign() > 0 {
		if closeOrder, ok = s.ClosePosition(ctx); !ok {
			log.Errorf("buy position %v remained not closed, skip placing order", base)
			return closeOrder, nil
		}
	}
	if s.Position.GetBase().Sign() > 0 {
		// we are not able to make close trade at this moment,
		// will close the rest of the position by normal limit order
		// s.entryPrice is set in the last trade
		waitForTrade = true
	}
	baseBalance, ok := s.Session.GetAccount().Balance(s.Market.BaseCurrency)
	if !ok {
		return closeOrder, nil
	}
	order := types.SubmitOrder{
		Symbol:      s.Symbol,
		Side:        types.SideTypeSell,
		Type:        types.OrderTypeLimit,
		Market:      s.Market,
		Quantity:    baseBalance.Available,
		Price:       price,
		TimeInForce: types.TimeInForceGTC,
	}
	if err := s.validateOrder(&order); err != nil {
		log.Infof("validation failed %v: %v", order, err)
		return closeOrder, nil
	}

	log.Warnf("short at %v, position %v closeOrder %v, timestamp: %s", price, s.Position.GetBase(), closeOrder, s.KLineStartTime)
	createdOrders, err := s.Session.Exchange.SubmitOrders(ctx, order)
	if err != nil {
		log.WithError(err).Errorf("cannot place order")
		return closeOrder, nil
	}
	log.Infof("post order, c: %v, entryPrice: %v o: %v", waitForTrade, s.entryPrice, createdOrders)
	s.waitForTrade = waitForTrade
	s.orderStore.Add(createdOrders...)
	s.activeMakerOrders.Add(createdOrders...)
	s.tradeCollector.Process()
	return closeOrder, &createdOrders[0]
}

// ClosePosition(context.Context) -> (closeOrder *types.Order, ok bool)
// this will decorate the generated order from NewMarketCloseOrder
// add do necessary checks
// if available quantity is zero, will return (nil, true)
// if any of the checks failed, will return (nil, false)
// otherwise, return the created close order and true
func (s *Strategy) ClosePosition(ctx context.Context) (*types.Order, bool) {
	order := s.Position.NewMarketCloseOrder(fixedpoint.One)
	// no position exists
	if order == nil {
		// no base
		s.sellPrice = fixedpoint.Zero
		s.buyPrice = fixedpoint.Zero
		return nil, true
	}
	order.TimeInForce = ""
	// If there's any order not yet been traded in the orderbook,
	// we need this additional check to make sure we have enough balance to post a close order
	balances := s.Session.GetAccount().Balances()
	baseBalance := balances[s.Market.BaseCurrency].Available
	if order.Side == types.SideTypeBuy {
		price := s.GetLastPrice()
		quoteAmount := balances[s.Market.QuoteCurrency].Available.Div(price)
		if order.Quantity.Compare(quoteAmount) > 0 {
			order.Quantity = quoteAmount
		}
	} else if order.Side == types.SideTypeSell && order.Quantity.Compare(baseBalance) > 0 {
		order.Quantity = baseBalance
	}
	// if no available balance...
	if order.Quantity.IsZero() {
		return nil, true
	}
	if err := s.validateOrder(order); err != nil {
		log.Errorf("cannot place close order %v: %v", order, err)
		return nil, false
	}

	createdOrders, err := s.Session.Exchange.SubmitOrders(ctx, *order)
	if err != nil {
		log.WithError(err).Errorf("cannot place close order")
		return nil, false
	}
	log.Infof("close order %v", createdOrders)
	s.orderStore.Add(createdOrders...)
	s.activeMakerOrders.Add(createdOrders...)
	s.tradeCollector.Process()
	return &createdOrders[0], true
}

func (s *Strategy) CancelAll(ctx context.Context) {
	var toCancel []types.Order
	for _, order := range s.orderStore.Orders() {
		if order.Status == types.OrderStatusNew || order.Status == types.OrderStatusPartiallyFilled {
			toCancel = append(toCancel, order)
		}
	}
	if len(toCancel) > 0 {
		if err := s.Session.Exchange.CancelOrders(ctx, toCancel...); err != nil {
			log.WithError(err).Errorf("cancel order error")
		}
		s.waitForTrade = false
	}
}

func (s *Strategy) GetLastPrice() fixedpoint.Value {
	var lastPrice fixedpoint.Value
	var ok bool
	if s.Environment.IsBackTesting() {
		lastPrice, ok = s.Session.LastPrice(s.Symbol)
		if !ok {
			log.Errorf("cannot get last price")
			return lastPrice
		}
	} else {
		s.lock.RLock()
		if s.midPrice.IsZero() {
			lastPrice, ok = s.Session.LastPrice(s.Symbol)
			if !ok {
				log.Errorf("cannot get last price")
				return lastPrice
			}
		} else {
			lastPrice = s.midPrice
		}
		s.lock.RUnlock()
	}
	return lastPrice
}

// Trading Rules:
// - buy / sell the whole asset
// - SL by atr (lastprice < buyprice - atr) || (lastprice > sellprice + atr)
// - TP by detecting if there's a ewo pivotHigh(1,1) -> close long, or pivotLow(1,1) -> close short
// - TP by ma34 +- atr * 2
// - TP by (lastprice < peak price - atr) || (lastprice > bottom price + atr)
// - SL by s.Stoploss (Abs(price_diff / price) > s.Stoploss)
// - entry condition on ewo(Elliott wave oscillator) Crosses ewoSignal(ma on ewo, signalWindow)
//   * buy signal on (crossover on previous K bar and no crossunder on latest K bar)
//   * sell signal on (crossunder on previous K bar and no crossunder on latest K bar)
// - and filtered by the following rules:
//   * buy: buy signal ON, kline Close > Open, Close > ma5, Close > ma34, CCI Stochastic Buy signal
//   * sell: sell signal ON, kline Close < Open, Close < ma5, Close < ma34, CCI Stochastic Sell signal
// - or entry when ma34 +- atr * 3 gets touched
// - entry price: latestPrice +- atr / 2 (short,long), close at market price
// Cancel non-fully filled orders on new signal (either in same direction or not)
//
// ps: kline might refer to heikinashi or normal ohlc
func (s *Strategy) Run(ctx context.Context, orderExecutor bbgo.OrderExecutor, session *bbgo.ExchangeSession) error {
	s.buyPrice = fixedpoint.Zero
	s.sellPrice = fixedpoint.Zero
	s.peakPrice = fixedpoint.Zero
	s.bottomPrice = fixedpoint.Zero

	counterTPfromPeak := 0
	percentAvgTPfromPeak := 0.0
	counterTPfromCCI := 0
	percentAvgTPfromCCI := 0.0
	counterTPfromLongShort := 0
	percentAvgTPfromLongShort := 0.0
	counterTPfromAtr := 0
	percentAvgTPfromAtr := 0.0
	counterTPfromOrder := 0
	percentAvgTPfromOrder := 0.0
	counterSLfromSL := 0
	percentAvgSLfromSL := 0.0
	counterSLfromOrder := 0
	percentAvgSLfromOrder := 0.0

	s.activeMakerOrders = bbgo.NewActiveOrderBook(s.Symbol)
	s.activeMakerOrders.BindStream(session.UserDataStream)

	s.orderStore = bbgo.NewOrderStore(s.Symbol)
	s.orderStore.BindStream(session.UserDataStream)

	if s.Position == nil {
		s.Position = types.NewPositionFromMarket(s.Market)
	}
	if s.ProfitStats == nil {
		s.ProfitStats = types.NewProfitStats(s.Market)
	}
	s.tradeCollector = bbgo.NewTradeCollector(s.Symbol, s.Position, s.orderStore)
	s.tradeCollector.OnTrade(func(trade types.Trade, profit, netprofit fixedpoint.Value) {
		if s.Symbol != trade.Symbol {
			return
		}
		bbgo.Notify(trade)
		s.ProfitStats.AddTrade(trade)

		if !profit.IsZero() {
			log.Warnf("generate profit: %v, netprofit: %v, trade: %v", profit, netprofit, trade)
			p := s.Position.NewProfit(trade, profit, netprofit)
			p.Strategy = ID
			p.StrategyInstanceID = s.InstanceID()
			bbgo.Notify(&p)

			s.ProfitStats.AddProfit(p)
			bbgo.Notify(&s.ProfitStats)
			s.Environment.RecordPosition(s.Position, trade, &p)
		} else {
			s.Environment.RecordPosition(s.Position, trade, nil)
		}
		// calculate report for the position that cannot be closed by close order (amount too small)
		if s.waitForTrade {
			price := s.entryPrice
			if price.IsZero() {
				panic("no price found")
			}
			pnlRate := trade.Price.Sub(price).Abs().Div(trade.Price).Float64()
			if s.Record {
				log.Errorf("record avg %v trade %v", price, trade)
			}
			if trade.Side == types.SideTypeBuy {
				if trade.Price.Compare(price) < 0 {
					percentAvgTPfromOrder = percentAvgTPfromOrder*float64(counterTPfromOrder) + pnlRate
					counterTPfromOrder += 1
					percentAvgTPfromOrder /= float64(counterTPfromOrder)
				} else {
					percentAvgSLfromOrder = percentAvgSLfromOrder*float64(counterSLfromOrder) + pnlRate
					counterSLfromOrder += 1
					percentAvgSLfromOrder /= float64(counterSLfromOrder)
				}
			} else if trade.Side == types.SideTypeSell {
				if trade.Price.Compare(price) > 0 {
					percentAvgTPfromOrder = percentAvgTPfromOrder*float64(counterTPfromOrder) + pnlRate
					counterTPfromOrder += 1
					percentAvgTPfromOrder /= float64(counterTPfromOrder)
				} else {
					percentAvgSLfromOrder = percentAvgSLfromOrder*float64(counterSLfromOrder) + pnlRate
					counterSLfromOrder += 1
					percentAvgSLfromOrder /= float64(counterSLfromOrder)
				}
			} else {
				panic(fmt.Sprintf("no sell(%v) or buy price(%v), %v", s.sellPrice, s.buyPrice, trade))
			}
			s.waitForTrade = false
		}
		if s.Position.GetBase().Abs().Compare(s.Market.MinQuantity) >= 0 && s.Position.GetBase().Abs().Mul(trade.Price).Compare(s.Market.MinNotional) >= 0 {
			sign := s.Position.GetBase().Sign()
			if sign > 0 {
				log.Infof("base become positive, %v", trade)
				s.buyPrice = s.Position.AverageCost
				s.sellPrice = fixedpoint.Zero
				s.peakPrice = s.Position.AverageCost
			} else if sign == 0 {
				panic("not going to happen")
			} else {
				log.Infof("base become negative, %v", trade)
				s.buyPrice = fixedpoint.Zero
				s.sellPrice = s.Position.AverageCost
				s.bottomPrice = s.Position.AverageCost
			}
			s.entryPrice = trade.Price
		} else {
			log.Infof("base become zero, rest of base: %v", s.Position.GetBase())
			if s.Position.GetBase().IsZero() {
				s.entryPrice = fixedpoint.Zero
			}
			s.buyPrice = fixedpoint.Zero
			s.sellPrice = fixedpoint.Zero
			s.peakPrice = fixedpoint.Zero
			s.bottomPrice = fixedpoint.Zero
		}
	})

	s.tradeCollector.OnPositionUpdate(func(position *types.Position) {
		log.Infof("position changed: %s", position)
		bbgo.Notify(s.Position)
	})
	s.tradeCollector.BindStream(session.UserDataStream)

	store, ok := s.Session.MarketDataStore(s.Symbol)
	if !ok {
		return fmt.Errorf("cannot get marketdatastore of %s", s.Symbol)
	}
	s.SetupIndicators(store)

	// local peak of ewo
	shortSig := s.ewo.Last() < s.ewo.Index(1) && s.ewo.Index(1) > s.ewo.Index(2)
	longSig := s.ewo.Last() > s.ewo.Index(1) && s.ewo.Index(1) < s.ewo.Index(2)

	sellOrderTPSL := func(price fixedpoint.Value) {
		lastPrice := s.GetLastPrice()
		base := s.Position.GetBase().Abs()
		if base.Mul(lastPrice).Compare(s.Market.MinNotional) < 0 || base.Compare(s.Market.MinQuantity) < 0 {
			return
		}
		if s.sellPrice.IsZero() {
			return
		}
		balances := session.GetAccount().Balances()
		quoteBalance := balances[s.Market.QuoteCurrency].Available
		atr := fixedpoint.NewFromFloat(s.atr.Last())
		atrx2 := fixedpoint.NewFromFloat(s.atr.Last() * 2)
		buyall := false
		if s.bottomPrice.IsZero() || s.bottomPrice.Compare(price) > 0 {
			s.bottomPrice = price
		}
		takeProfit := false
		bottomBack := s.bottomPrice
		spBack := s.sellPrice
		reason := -1
		if quoteBalance.Div(lastPrice).Compare(s.Market.MinQuantity) >= 0 && quoteBalance.Compare(s.Market.MinNotional) >= 0 {
			base := fixedpoint.NewFromFloat(s.ma34.Last())
			// TP
			if lastPrice.Compare(s.sellPrice) < 0 && (longSig ||
				(!atrx2.IsZero() && base.Sub(atrx2).Compare(lastPrice) >= 0)) {
				buyall = true
				takeProfit = true

				// calculate report
				if longSig {
					reason = 1
				} else {
					reason = 2
				}

			}
			if !atr.IsZero() && s.bottomPrice.Add(atr).Compare(lastPrice) <= 0 &&
				lastPrice.Compare(s.sellPrice) < 0 {
				buyall = true
				takeProfit = true
				reason = 3
			}

			// SL
			/*if (!atrx2.IsZero() && s.bottomPrice.Add(atrx2).Compare(lastPrice) <= 0) ||
				lastPrice.Sub(s.bottomPrice).Div(lastPrice).Compare(s.Stoploss) > 0 {
				if lastPrice.Compare(s.sellPrice) < 0 {
					takeProfit = true
				}
				buyall = true
				s.bottomPrice = fixedpoint.Zero
			}*/
			if !s.DisableShortStop && ((!atr.IsZero() && s.sellPrice.Sub(atr).Compare(lastPrice) >= 0) ||
				lastPrice.Sub(s.sellPrice).Div(s.sellPrice).Compare(s.Stoploss) > 0) {
				buyall = true
				reason = 4
			}
		}
		if buyall {
			log.Warnf("buyall TPSL %v %v", s.Position.GetBase(), quoteBalance)
			p := s.sellPrice
			if order, ok := s.ClosePosition(ctx); order != nil && ok {
				if takeProfit {
					log.Errorf("takeprofit buy at %v, avg %v, l: %v, atrx2: %v", lastPrice, spBack, bottomBack, atrx2)
				} else {
					log.Errorf("stoploss buy at %v, avg %v, l: %v, atrx2: %v", lastPrice, spBack, bottomBack, atrx2)
				}

				// calculate report
				if s.Record {
					log.Error("record ba")
				}
				var pnlRate float64
				if takeProfit {
					pnlRate = p.Sub(lastPrice).Div(lastPrice).Float64()
				} else {
					pnlRate = lastPrice.Sub(p).Div(lastPrice).Float64()
				}
				switch reason {
				case 0:
					percentAvgTPfromCCI = percentAvgTPfromCCI*float64(counterTPfromCCI) + pnlRate
					counterTPfromCCI += 1
					percentAvgTPfromCCI /= float64(counterTPfromCCI)
				case 1:
					percentAvgTPfromLongShort = percentAvgTPfromLongShort*float64(counterTPfromLongShort) + pnlRate
					counterTPfromLongShort += 1
					percentAvgTPfromLongShort /= float64(counterTPfromLongShort)
				case 2:
					percentAvgTPfromAtr = percentAvgTPfromAtr*float64(counterTPfromAtr) + pnlRate
					counterTPfromAtr += 1
					percentAvgTPfromAtr /= float64(counterTPfromAtr)
				case 3:
					percentAvgTPfromPeak = percentAvgTPfromPeak*float64(counterTPfromPeak) + pnlRate
					counterTPfromPeak += 1
					percentAvgTPfromPeak /= float64(counterTPfromPeak)
				case 4:
					percentAvgSLfromSL = percentAvgSLfromSL*float64(counterSLfromSL) + pnlRate
					counterSLfromSL += 1
					percentAvgSLfromSL /= float64(counterSLfromSL)

				}
			}
		}
	}
	buyOrderTPSL := func(price fixedpoint.Value) {
		lastPrice := s.GetLastPrice()
		base := s.Position.GetBase().Abs()
		if base.Mul(lastPrice).Compare(s.Market.MinNotional) < 0 || base.Compare(s.Market.MinQuantity) < 0 {
			return
		}
		if s.buyPrice.IsZero() {
			return
		}
		balances := session.GetAccount().Balances()
		baseBalance := balances[s.Market.BaseCurrency].Available
		atr := fixedpoint.NewFromFloat(s.atr.Last())
		atrx2 := fixedpoint.NewFromFloat(s.atr.Last() * 2)
		sellall := false
		if s.peakPrice.IsZero() || s.peakPrice.Compare(price) < 0 {
			s.peakPrice = price
		}
		takeProfit := false
		peakBack := s.peakPrice
		bpBack := s.buyPrice
		reason := -1
		if baseBalance.Compare(s.Market.MinQuantity) >= 0 && baseBalance.Mul(lastPrice).Compare(s.Market.MinNotional) >= 0 {
			// TP
			base := fixedpoint.NewFromFloat(s.ma34.Last())
			if lastPrice.Compare(s.buyPrice) > 0 && (shortSig ||
				(!atrx2.IsZero() && base.Add(atrx2).Compare(lastPrice) <= 0)) {
				sellall = true
				takeProfit = true

				// calculate report
				if shortSig {
					reason = 1
				} else {
					reason = 2
				}
			}
			if !atr.IsZero() && s.peakPrice.Sub(atr).Compare(lastPrice) >= 0 &&
				lastPrice.Compare(s.buyPrice) > 0 {
				sellall = true
				takeProfit = true
				reason = 3
			}

			// SL
			/*if s.peakPrice.Sub(lastPrice).Div(s.peakPrice).Compare(s.Stoploss) > 0 ||
				(!atrx2.IsZero() && s.peakPrice.Sub(atrx2).Compare(lastPrice) >= 0) {
				if lastPrice.Compare(s.buyPrice) > 0 {
					takeProfit = true
				}
				sellall = true
				s.peakPrice = fixedpoint.Zero
			}*/
			if !s.DisableLongStop && (s.buyPrice.Sub(lastPrice).Div(s.buyPrice).Compare(s.Stoploss) > 0 ||
				(!atr.IsZero() && s.buyPrice.Sub(atr).Compare(lastPrice) >= 0)) {
				sellall = true
				reason = 4
			}
		}

		if sellall {
			log.Warnf("sellall TPSL %v", s.Position.GetBase())
			p := s.buyPrice
			if order, ok := s.ClosePosition(ctx); order != nil && ok {
				if takeProfit {
					log.Errorf("takeprofit sell at %v, avg %v, h: %v, atrx2: %v", lastPrice, bpBack, peakBack, atrx2)
				} else {
					log.Errorf("stoploss sell at %v, avg %v, h: %v, atrx2: %v", lastPrice, bpBack, peakBack, atrx2)
				}
				// calculate report
				if s.Record {
					log.Error("record sa")
				}
				var pnlRate float64
				if takeProfit {
					pnlRate = lastPrice.Sub(p).Div(p).Float64()
				} else {
					pnlRate = p.Sub(lastPrice).Div(p).Float64()
				}
				switch reason {
				case 0:
					percentAvgTPfromCCI = percentAvgTPfromCCI*float64(counterTPfromCCI) + pnlRate
					counterTPfromCCI += 1
					percentAvgTPfromCCI /= float64(counterTPfromCCI)
				case 1:
					percentAvgTPfromLongShort = percentAvgTPfromLongShort*float64(counterTPfromLongShort) + pnlRate
					counterTPfromLongShort += 1
					percentAvgTPfromLongShort /= float64(counterTPfromLongShort)
				case 2:
					percentAvgTPfromAtr = percentAvgTPfromAtr*float64(counterTPfromAtr) + pnlRate
					counterTPfromAtr += 1
					percentAvgTPfromAtr /= float64(counterTPfromAtr)
				case 3:
					percentAvgTPfromPeak = percentAvgTPfromPeak*float64(counterTPfromPeak) + pnlRate
					counterTPfromPeak += 1
					percentAvgTPfromPeak /= float64(counterTPfromPeak)
				case 4:
					percentAvgSLfromSL = percentAvgSLfromSL*float64(counterSLfromSL) + pnlRate
					counterSLfromSL += 1
					percentAvgSLfromSL /= float64(counterSLfromSL)
				}
			}
		}
	}

	// set last price by realtime book ticker update
	// to trigger TP/SL
	session.MarketDataStream.OnBookTickerUpdate(func(ticker types.BookTicker) {
		if s.Environment.IsBackTesting() {
			return
		}
		bestBid := ticker.Buy
		bestAsk := ticker.Sell
		var midPrice fixedpoint.Value

		if tryLock(&s.lock) {
			if !bestAsk.IsZero() && !bestBid.IsZero() {
				s.midPrice = bestAsk.Add(bestBid).Div(types.Two)
			} else if !bestAsk.IsZero() {
				s.midPrice = bestAsk
			} else {
				s.midPrice = bestBid
			}
			midPrice = s.midPrice
			s.lock.Unlock()
		}

		if !midPrice.IsZero() {
			buyOrderTPSL(midPrice)
			sellOrderTPSL(midPrice)
			// log.Debugf("best bid %v, best ask %v, mid %v", bestBid, bestAsk, midPrice)
		}
	})

	getHigh := func(window types.KLineWindow) types.Series {
		if s.UseHeikinAshi {
			return s.heikinAshi.High
		}
		return window.High()
	}
	getLow := func(window types.KLineWindow) types.Series {
		if s.UseHeikinAshi {
			return s.heikinAshi.Low
		}
		return window.Low()
	}
	getClose := func(window types.KLineWindow) types.Series {
		if s.UseHeikinAshi {
			return s.heikinAshi.Close
		}
		return window.Close()
	}
	getOpen := func(window types.KLineWindow) types.Series {
		if s.UseHeikinAshi {
			return s.heikinAshi.Open
		}
		return window.Open()
	}

	store.OnKLineWindowUpdate(func(interval types.Interval, window types.KLineWindow) {
		kline := window[len(window)-1]
		s.KLineStartTime = kline.StartTime
		s.KLineEndTime = kline.EndTime

		// well, only track prices on 1m
		if interval == types.Interval1m {

			if s.Environment.IsBackTesting() {
				buyOrderTPSL(kline.High)
				sellOrderTPSL(kline.Low)

			}
		}

		var lastPrice fixedpoint.Value
		var ok bool
		if s.Environment.IsBackTesting() {
			lastPrice, ok = session.LastPrice(s.Symbol)
			if !ok {
				log.Errorf("cannot get last price")
				return
			}
		} else {
			s.lock.RLock()
			if s.midPrice.IsZero() {
				lastPrice, ok = session.LastPrice(s.Symbol)
				if !ok {
					log.Errorf("cannot get last price")
					return
				}
			} else {
				lastPrice = s.midPrice
			}
			s.lock.RUnlock()
		}
		balances := session.GetAccount().Balances()
		baseBalance := balances[s.Market.BaseCurrency].Total()
		quoteBalance := balances[s.Market.QuoteCurrency].Total()
		atr := fixedpoint.NewFromFloat(s.atr.Last())
		if !s.Environment.IsBackTesting() {
			log.Infof("Get last price: %v, ewo %f, ewoSig %f, ccis: %f, atr %v, kline: %v, balance[base]: %v balance[quote]: %v",
				lastPrice, s.ewo.Last(), s.ewoSignal.Last(), s.ccis.ma.Last(), atr, kline, baseBalance, quoteBalance)
		}

		if kline.Interval != s.Interval {
			return
		}

		priceHighest := types.Highest(getHigh(window), 233)
		priceLowest := types.Lowest(getLow(window), 233)
		priceChangeRate := (priceHighest - priceLowest) / priceHighest / 14
		ewoHighest := types.Highest(s.ewoHistogram, 233)

		s.ewoChangeRate = math.Abs(s.ewoHistogram.Last() / ewoHighest * priceChangeRate)

		longSignal := types.CrossOver(s.ewo, s.ewoSignal)
		shortSignal := types.CrossUnder(s.ewo, s.ewoSignal)

		base := s.ma34.Last()
		sellLine := base + s.atr.Last()*3
		buyLine := base - s.atr.Last()*3
		clozes := getClose(window)
		opens := getOpen(window)

		// get trend flags
		bull := clozes.Last() > opens.Last()
		breakThrough := clozes.Last() > s.ma5.Last() && clozes.Last() > s.ma34.Last()
		breakDown := clozes.Last() < s.ma5.Last() && clozes.Last() < s.ma34.Last()

		// kline breakthrough ma5, ma34 trend up, and cci Stochastic bull
		IsBull := bull && breakThrough && s.ccis.BuySignal() && s.ewoChangeRate < s.EwoChangeFilterHigh && s.ewoChangeRate > s.EwoChangeFilterLow
		// kline downthrough ma5, ma34 trend down, and cci Stochastic bear
		IsBear := !bull && breakDown && s.ccis.SellSignal() && s.ewoChangeRate < s.EwoChangeFilterHigh && s.ewoChangeRate > s.EwoChangeFilterLow

		if !s.Environment.IsBackTesting() {
			log.Infof("IsBull: %v, bull: %v, longSignal[1]: %v, shortSignal: %v, lastPrice: %v",
				IsBull, bull, longSignal.Index(1), shortSignal.Last(), lastPrice)
			log.Infof("IsBear: %v, bear: %v, shortSignal[1]: %v, longSignal: %v, lastPrice: %v",
				IsBear, !bull, shortSignal.Index(1), longSignal.Last(), lastPrice)
		}

		if (longSignal.Index(1) && !shortSignal.Last() && IsBull) || lastPrice.Float64() <= buyLine {
			price := lastPrice.Sub(atr.Div(types.Two))
			// if total asset (including locked) could be used to buy
			if quoteBalance.Div(price).Compare(s.Market.MinQuantity) >= 0 && quoteBalance.Compare(s.Market.MinNotional) >= 0 {
				// cancel all orders to release lock
				s.CancelAll(ctx)

				// backup, since the s.sellPrice will be cleared when doing ClosePosition
				sellPrice := s.sellPrice
				log.Errorf("ewoChangeRate %v, emv %v", s.ewoChangeRate, s.emv.Last())

				// calculate report
				if closeOrder, _ := s.PlaceBuyOrder(ctx, price); closeOrder != nil {
					if s.Record {
						log.Error("record l")
					}
					if !sellPrice.IsZero() {
						if lastPrice.Compare(sellPrice) > 0 {
							pnlRate := lastPrice.Sub(sellPrice).Div(lastPrice).Float64()
							percentAvgTPfromOrder = percentAvgTPfromOrder*float64(counterTPfromOrder) + pnlRate
							counterTPfromOrder += 1
							percentAvgTPfromOrder /= float64(counterTPfromOrder)
						} else {
							pnlRate := sellPrice.Sub(lastPrice).Div(lastPrice).Float64()
							percentAvgSLfromOrder = percentAvgSLfromOrder*float64(counterSLfromOrder) + pnlRate
							counterSLfromOrder += 1
							percentAvgSLfromOrder /= float64(counterSLfromOrder)
						}
					} else {
						panic("no sell price")
					}
				}
			}
		}
		if (shortSignal.Index(1) && !longSignal.Last() && IsBear) || lastPrice.Float64() >= sellLine {
			price := lastPrice.Add(atr.Div(types.Two))
			// if total asset (including locked) could be used to sell
			if baseBalance.Mul(price).Compare(s.Market.MinNotional) >= 0 && baseBalance.Compare(s.Market.MinQuantity) >= 0 {
				// cancel all orders to release lock
				s.CancelAll(ctx)

				// backup, since the s.buyPrice will be cleared when doing ClosePosition
				buyPrice := s.buyPrice
				log.Errorf("ewoChangeRate: %v, emv %v", s.ewoChangeRate, s.emv.Last())

				// calculate report
				if closeOrder, _ := s.PlaceSellOrder(ctx, price); closeOrder != nil {
					if s.Record {
						log.Error("record s")
					}
					if !buyPrice.IsZero() {
						if lastPrice.Compare(buyPrice) > 0 {
							pnlRate := lastPrice.Sub(buyPrice).Div(buyPrice).Float64()
							percentAvgTPfromOrder = percentAvgTPfromOrder*float64(counterTPfromOrder) + pnlRate
							counterTPfromOrder += 1
							percentAvgTPfromOrder /= float64(counterTPfromOrder)
						} else {
							pnlRate := buyPrice.Sub(lastPrice).Div(buyPrice).Float64()
							percentAvgSLfromOrder = percentAvgSLfromOrder*float64(counterSLfromOrder) + pnlRate
							counterSLfromOrder += 1
							percentAvgSLfromOrder /= float64(counterSLfromOrder)
						}
					} else {
						panic("no buy price")
					}
				}
			}
		}
	})
	s.Graceful.OnShutdown(func(ctx context.Context, wg *sync.WaitGroup) {
		defer wg.Done()
		log.Infof("canceling active orders...")
		s.CancelAll(ctx)

		s.tradeCollector.Process()
		hiblue := color.New(color.FgHiBlue).FprintfFunc()
		blue := color.New(color.FgBlue).FprintfFunc()
		hiyellow := color.New(color.FgHiYellow).FprintfFunc()
		hiblue(os.Stderr, "---- Trade Report (Without Fee) ----\n")
		hiblue(os.Stderr, "TP:\n")
		blue(os.Stderr, "\tpeak / bottom with atr: %d, avg pnl rate: %f\n", counterTPfromPeak, percentAvgTPfromPeak)
		blue(os.Stderr, "\tCCI Stochastic: %d, avg pnl rate: %f\n", counterTPfromCCI, percentAvgTPfromCCI)
		blue(os.Stderr, "\tLongSignal/ShortSignal: %d, avg pnl rate: %f\n", counterTPfromLongShort, percentAvgTPfromLongShort)
		blue(os.Stderr, "\tma34 and Atrx2: %d, avg pnl rate: %f\n", counterTPfromAtr, percentAvgTPfromAtr)
		blue(os.Stderr, "\tActive Order: %d, avg pnl rate: %f\n", counterTPfromOrder, percentAvgTPfromOrder)

		totalTP := counterTPfromPeak + counterTPfromCCI + counterTPfromLongShort + counterTPfromAtr + counterTPfromOrder
		avgProfit := (float64(counterTPfromPeak)*percentAvgTPfromPeak +
			float64(counterTPfromCCI)*percentAvgTPfromCCI +
			float64(counterTPfromLongShort)*percentAvgTPfromLongShort +
			float64(counterTPfromAtr)*percentAvgTPfromAtr +
			float64(counterTPfromOrder)*percentAvgTPfromOrder) / float64(totalTP)
		hiblue(os.Stderr, "\tSum: %d, avg pnl rate: %f\n", totalTP, avgProfit)

		hiblue(os.Stderr, "SL:\n")
		blue(os.Stderr, "\tentry SL: %d, avg pnl rate: -%f\n", counterSLfromSL, percentAvgSLfromSL)
		blue(os.Stderr, "\tActive Order: %d, avg pnl rate: -%f\n", counterSLfromOrder, percentAvgSLfromOrder)

		totalSL := counterSLfromSL + counterSLfromOrder
		avgLoss := (float64(counterSLfromSL)*percentAvgSLfromSL + float64(counterSLfromOrder)*percentAvgSLfromOrder) / float64(totalSL)
		hiblue(os.Stderr, "\tSum: %d, avg pnl rate: -%f\n", totalSL, avgLoss)

		hiblue(os.Stderr, "WinRate: %f\n", float64(totalTP)/float64(totalTP+totalSL))

		maString := "vwema"
		if s.UseSma {
			maString = "sma"
		}
		if s.UseEma {
			maString = "ema"
		}

		hiyellow(os.Stderr, "----- EWO Settings -------\n")
		hiyellow(os.Stderr, "General:\n")
		hiyellow(os.Stderr, "\tuseHeikinAshi: %v\n", s.UseHeikinAshi)
		hiyellow(os.Stderr, "\tstoploss: %v\n", s.Stoploss)
		hiyellow(os.Stderr, "\tsymbol: %s\n", s.Symbol)
		hiyellow(os.Stderr, "\tinterval: %s\n", s.Interval)
		hiyellow(os.Stderr, "\tMA type: %s\n", maString)
		hiyellow(os.Stderr, "\tdisableShortStop: %v\n", s.DisableShortStop)
		hiyellow(os.Stderr, "\tdisableLongStop: %v\n", s.DisableLongStop)
		hiyellow(os.Stderr, "\trecord: %v\n", s.Record)
		hiyellow(os.Stderr, "CCI Stochastic:\n")
		hiyellow(os.Stderr, "\tccistochFilterHigh: %f\n", s.FilterHigh)
		hiyellow(os.Stderr, "\tccistochFilterLow: %f\n", s.FilterLow)
		hiyellow(os.Stderr, "Ewo && Ewo Histogram:\n")
		hiyellow(os.Stderr, "\tsigWin: %d\n", s.SignalWindow)
		hiyellow(os.Stderr, "\tewoChngFilterHigh: %f\n", s.EwoChangeFilterHigh)
		hiyellow(os.Stderr, "\tewoChngFilterLow: %f\n", s.EwoChangeFilterLow)
	})
	return nil
}