backtest

type Bar struct {
	Event
	DataEvent
	Open     float64
	High     float64
	Low      float64
	Close    float64
	AdjClose float64
	Volume   int64
}

type BarEvent interface {
	DataEventHandler
	IsBar() bool
}

type Casher interface {
	SetInitialCash(float64)
	InitialCash() float64
	SetCash(float64)
	Cash() float64
}

type Data struct {
	// contains filtered or unexported fields
}

type DataEvent struct {
	Metrics map[string]float64
}

type DataEventHandler interface {
	EventHandler
	IsDataEvent() bool
	LatestPrice() float64
}

type DataHandler interface {
	DataLoader
	DataStreamer
	Reseter
}

type DataLoader interface {
	Load([]string) error
}

type DataStreamer interface {
	Next() (DataEventHandler, bool)
	Stream() []DataEventHandler
	History() []DataEventHandler
	Latest(string) DataEventHandler
	List(string) []DataEventHandler
}

type Directioner interface {
	SetDirection(string)
	GetDirection() string
}

type Event struct {
	Timestamp time.Time
	Symbol    string
}

type EventHandler interface {
	IsEvent() bool
	Timer
	Symboler
}

type EventTracker interface {
	TrackEvent(EventHandler)
	Events() []EventHandler
}

type Exchange struct {
	Symbol      string
	ExchangeFee float64
}

type ExecutionHandler interface {
	ExecuteOrder(OrderEvent, DataHandler) (*Fill, error)
}

type Fill struct {
	Event
	Exchange    string // exchange symbol
	Direction   string // BOT for buy or SLD for sell
	Qty         int64
	Price       float64
	Commission  float64
	ExchangeFee float64
	Cost        float64 // the total cost of the filled order incl commission and fees
}

type FillEvent interface {
	EventHandler
	Directioner
	Quantifier
	IsFill() bool
	GetPrice() float64
	GetCommission() float64
	GetExchangeFee() float64
	GetCost() float64
	Value() float64
	NetValue() float64
}

type Investor interface {
	IsInvested(string) (position, bool)
	IsLong(string) (position, bool)
	IsShort(string) (position, bool)
}

type OnFiller interface {
	OnFill(FillEvent, DataHandler) (*Fill, error)
}

type OnSignaler interface {
	OnSignal(SignalEvent, DataHandler) (*Order, error)
}

type Order struct {
	Event
	Direction string  // buy or sell
	Qty       int64   // quantity of the order
	OrderType string  // market or limit
	Limit     float64 // limit for the order
}

type OrderEvent interface {
	EventHandler
	Directioner
	Quantifier
	IsOrder() bool
}

type Portfolio struct {
	// contains filtered or unexported fields
}

type PortfolioHandler interface {
	OnSignaler
	OnFiller
	Investor
	Updater
	Casher
	Valuer
	Reseter
}

type Quantifier interface {
	SetQty(int64)
	GetQty() int64
}

type Reseter interface {
	Reset()
}

type Resulter interface {
	TotalEquityReturn() (float64, error)
	MaxDrawdown() float64
	MaxDrawdownTime() time.Time
	MaxDrawdownDuration() time.Duration
	SharpRatio(float64) float64
	SortinoRatio(float64) float64
}

type Risk struct {
}

type RiskHandler interface {
	EvaluateOrder(OrderEvent, DataEventHandler, map[string]position) (*Order, error)
}

type Signal struct {
	Event
	Direction string // long or short
}

type SignalEvent interface {
	EventHandler
	Directioner
	IsSignal() bool
}

type Size struct {
	DefaultSize  int64
	DefaultValue float64
}

type SizeHandler interface {
	SizeOrder(OrderEvent, DataEventHandler, PortfolioHandler) (*Order, error)
}

type Statistic struct {
	// contains filtered or unexported fields
}

type StatisticHandler interface {
	EventTracker
	TransactionTracker
	StatisticPrinter
	Reseter
	StatisticUpdater
	Resulter
}

type StatisticPrinter interface {
	PrintResult()
}

type StatisticUpdater interface {
	Update(DataEventHandler, PortfolioHandler)
}

type StrategyHandler interface {
	CalculateSignal(DataEventHandler, DataHandler, PortfolioHandler) (SignalEvent, error)
}

type Symboler interface {
	GetSymbol() string
}

type Test struct {
	// contains filtered or unexported fields
}

type Tick struct {
	Event
	DataEvent
	Bid float64
	Ask float64
}

type TickEvent interface {
	DataEventHandler
	IsTick() bool
}

type Timer interface {
	GetTime() time.Time
}

type TransactionTracker interface {
	TrackTransaction(FillEvent)
	Transactions() []FillEvent
}

type Updater interface {
	Update(DataEventHandler)
}

type Valuer interface {
	Value() float64
}