core

type Apps struct {
	IApps
}

type BrokerOption struct {
	Name            string
	Version         string
	Strategy        IStrategy
	LogStore        *logging.LogStore
	Counter         *counter.RateCounter
	DBLocation      string
	Proxy           func() []database.Proxy
	Accounts        func() (data []accounts.Accounts)
	Tasks           func() (data []tasks.Tasks)
	AssetData       func() interface{}
	GetPoints       func(rates.CandleRequest) (map[int][]rates.Points, error)
	OnBrokersUpdate func(id string, data []brokers.SendStatus)
}

type Brokers struct {
	IBrokers
}

type BrokersCallback struct {
	GetStatsTasksTransactions func(opt controllers.GetTasksTransactions) (data tasks.StatsTask, err error)
	GetTasksTransactions      func(opt controllers.GetTasksTransactions) (data []brokers.Transactions, err error)
	GetTasksTest              func(opt controllers.GetTasksTestOption) (data []tasks.TestTasks, err error)
	ResetTasks                func(opt controllers.ResetTasks) (err error)
	TestTasks                 func(opt tasks.TestTasks) (err error)
	RunTestTasks              func(opt tasks.TestTasks) (err error)
	DeleteTestTasks           func(opt tasks.TestTasks) (err error)
	ResetTestTasks            func(opt tasks.TestTasks) (err error)
	OnSignal                  func(strategy.SendingSignal)
}

type Calculation struct {
	ICalculation
}

type Components struct {
	IComponents
}

type Control struct {
	IControl
}

type Database struct {
	IDatabase
}

type HTTPClient struct {
	IHTTPClient
}

type HTTPClientResponse struct {
	IHTTPClientResponse
	StatusCode int
}

type IApps interface {
	Run(func() *HTTPClient, func() *interfaces.WebsocketClient) bool
	SetCallback(data interface{})
	GetCallback() interface{}
}

type IBrokers interface {
	Name() string
	Version() string
	Run() bool
	Create(*IBrokersCallback) error
	GetAccounts(id string) ([]accounts.Accounts, error)
	CreateAccounts(controllers.CreateAccounts) error
	EditAccounts(controllers.CreateAccounts) error
	SetAccountActive(controllers.SetAccountActive) error
	DeleteAccount(controllers.DeleteAccount) error
	AddTasks(controllers.AddTasks) error
	EditTasks(controllers.EditTasks) error
	DeleteTasks(controllers.DeleteTasks) error
	ResetTasks(controllers.ResetTasks) error
	TestTasks(tasks.TestTasks) error
	GetTasks() (data []tasks.Tasks, err error)
	RunTestTasks(tasks.TestTasks) error
	DeleteTestTasks(tasks.TestTasks) error
	ResetTestTasks(tasks.TestTasks) error
	GetTasksTest(controllers.GetTasksTestOption) (data []tasks.TestTasks, err error)
	GetTasksTransactions(controllers.GetTasksTransactions) (data []brokers.Transactions, err error)
	GetStatsTasksTransactions(controllers.GetTasksTransactions) (data tasks.StatsTask, err error)
	RegisterOnSignal() func(strategy.SendingSignal)
}

type IBrokersCallback struct {
	Strategy        IStrategy
	Logger          *logging.Logger
	LogStore        *logging.LogStore
	Database        *Database
	HTTPClient      func() *HTTPClient
	Counter         *counter.RateCounter
	GwAddress       controllers.GatewayAddress
	Config          []config.BrokersModules
	Components      *Components
	Stores          *brokers.Stores
	DBLocation      string
	GetAssetData    func(string) interface{}
	GetPoints       func(string, rates.CandleRequest) (map[int][]rates.Points, error)
	OnBrokersUpdate func(id string, data []brokers.SendStatus)
}

type ICalculation interface {
	New()
	GetValue(int, int) []float64
	GetValues(int, int) []rates.Points
	GetCurrent(int) rates.Points
	GetServerTime() time.Time
	GetSendTime() time.Time
	GetLogger() *logging.Logger
	GetAssetID() string
	GetAsset() database.Assets
	GetPoints(opt rates.CandleRequest) (map[int][]rates.Points, error)
	GetIndicator(string) IIndicator
}

type IComponents interface {
	GetStatsCache() (items []components.AllStats)
	GetAllStats() (items []components.AllStats)
	UpdateNetworkStats(msg monitor.IOCount)
	Register(items *components.Items)
	SetActive(name string, active bool)
	Run(ID string, exc string, opts []string, callback func())
	Stores() *components.Stores
	SetLogsLocation(string)
	OnLogsUpdate(string, func(string, logging.LogsValue))
	StoreLog(key string, msg interface{})
	GetLog(id string, start int64, limit int) []logging.LogsValue
	ClearLogs(id string, ts []int64)
	OnNewLogs(*logging.PushLogs)
}

type IControl interface {
	Run()
	SetConfig(config.Config)
	SetLogger(*logging.Logger)
	SetLogStore(*logging.LogStore)
	OnNewLogs(*logging.PushLogs)
}

type IDatabase interface {
	InsertAssetsProvider(opt database.AssetProvider) error
	GetAssets() map[string]database.Assets
	Init() (err error)
	Load() (err error)
	GetAll(bucket string) (res interface{})
	InsertToken(opt database.Token) error
	GenerateToken() string
	GetLocation() string
	SetLocation(string)
	UpdateUserAgent()
	GetUserAgent() map[string]utility.UserAgent
	UpdateUsers(database.Users) error
	InsertUsers(database.Users) error
	Stores() *database.Stores
	InsertProxy(opt database.Proxy) error
	EditProxy(opt database.Proxy) error
	DeleteProxy(opt database.Proxy) error
	AddProxyUsedBy(ID string, us database.ProxyUsed) error
	RemoveProxyUsedBy(ID string, UsedID string) error
}

type IHTTPClient interface {
	WithHeader(k, v string) *HTTPClient
	WithOption(k int, v interface{}) *HTTPClient
	Post(url string, params interface{}) (res *HTTPClientResponse, err error)
}

type IHTTPClientResponse interface {
	ReadAll() ([]byte, error)
}

type IIndicator interface {
	Name() string
	Version() string
	Title() string
	Init(IndicatorOptions)
	Trigger() map[int]string
	Calculation(string, *Calculation, map[string]interface{}) (indicator.Result, error)
	IsValid(*Calculation, map[string]interface{}, string) bool
}

type IRates interface {
	Name() string
	Version() string
	Run() bool
	Create(*IRatesCallback) error
	SetRatesAsset(controllers.SetRatesAsset) error
	SetRatesProviderConfig(databasetype.ProviderConfig) error
	SetRatesProviderConfigIgnores() map[string]bool
	EnableAsset(string) bool
	GetAssetData() (data interface{})
	GetPoints(rates.CandleRequest) (map[int][]rates.Points, error)
}

type IRatesCallback struct {
	Logger        *logging.Logger
	LogStore      *logging.LogStore
	Database      *Database
	HTTPClient    func() *HTTPClient
	Stores        *rates.Stores
	Counter       *counter.RateCounter
	GwAddress     controllers.GatewayAddress
	Config        []config.RatesModules
	Components    *Components
	Strategy      IStrategy
	OnRatesUpdate func(string, []rates.SendStatus)
}

type IStrategy interface {
	GetIndicatorList() ([]indicator.Indicator, error)
	GetStrategy(string) (data []strategy.Strategy, err error)
	AddStrategy(string, strategy.Strategy) (err error)
	EditStrategy(string, strategy.Strategy) (err error)
	DeleteStrategy(string, strategy.Strategy) (err error)
	OnBrokersRegister(data strategy.BrokersRegister)
	MultiCalculation(req []rates.SendPoints)
	Calculation(req rates.SendPoints, reqMulti []rates.SendPoints)
	EnableAssets() (assetData []rates.AssetCandleRequest)
}

type IWebapp interface {
	Create(*mux.Router)
	Render(*http.Request) []byte
}

type Indicator struct {
	IIndicator
}

type IndicatorOptions struct {
	DBLocation string
	Logger     *logging.Logger
}

type ProxyURL struct {
	Host     string
	Scheme   string
	Path     string
	Port     int
	Origin   string
	Username string
	Password string
	WithAuth bool
}

type Rates struct {
	IRates
}

type RatesCallback struct {
	AssetData func() iqoption.AssetsData
	GetPoints func(rates.CandleRequest) (map[int][]rates.Points, error)
}

type RatesOption struct {
	Name          string
	Version       string
	Strategy      IStrategy
	LogStore      *logging.LogStore
	Counter       *counter.RateCounter
	DBLocation    string
	Config        func() database.ProviderConfig
	Assets        func() []database.Assets
	Proxy         func() []database.Proxy
	SendStatus    func([]rates.SendStatus)
	OnRatesUpdate func(id string, data []rates.SendStatus)
	ResetToken    func(callback func()) (err error)
}

type StrategyOption struct {
	DatabaseLocation string
	LogStore         *logging.LogStore
	AssetProvider    func() map[string]string
	OnSignal         func([]string, strategy.SendingSignal)
}

type Webapp struct {
	IWebapp
}