gocryptotrader/exchanges/ftx/ftx_wrapper.go

package ftx

import (
	"context"
	"errors"
	"fmt"
	"math"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/shopspring/decimal"
	"github.com/thrasher-corp/gocryptotrader/common"
	"github.com/thrasher-corp/gocryptotrader/config"
	"github.com/thrasher-corp/gocryptotrader/currency"
	exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
	"github.com/thrasher-corp/gocryptotrader/exchanges/account"
	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
	"github.com/thrasher-corp/gocryptotrader/exchanges/deposit"
	"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
	"github.com/thrasher-corp/gocryptotrader/exchanges/margin"
	"github.com/thrasher-corp/gocryptotrader/exchanges/order"
	"github.com/thrasher-corp/gocryptotrader/exchanges/orderbook"
	"github.com/thrasher-corp/gocryptotrader/exchanges/protocol"
	"github.com/thrasher-corp/gocryptotrader/exchanges/request"
	"github.com/thrasher-corp/gocryptotrader/exchanges/stream"
	"github.com/thrasher-corp/gocryptotrader/exchanges/ticker"
	"github.com/thrasher-corp/gocryptotrader/exchanges/trade"
	"github.com/thrasher-corp/gocryptotrader/log"
	"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)

// GetDefaultConfig returns a default exchange config
func (f *FTX) GetDefaultConfig() (*config.Exchange, error) {
	f.SetDefaults()
	exchCfg := new(config.Exchange)
	exchCfg.Name = f.Name
	exchCfg.HTTPTimeout = exchange.DefaultHTTPTimeout
	exchCfg.BaseCurrencies = f.BaseCurrencies

	err := f.SetupDefaults(exchCfg)
	if err != nil {
		return nil, err
	}

	if f.Features.Supports.RESTCapabilities.AutoPairUpdates {
		err = f.UpdateTradablePairs(context.TODO(), true)
		if err != nil {
			return nil, err
		}
	}
	return exchCfg, nil
}

// SetDefaults sets the basic defaults for FTX
func (f *FTX) SetDefaults() {
	f.Name = "FTX"
	f.Enabled = true
	f.Verbose = true
	f.API.CredentialsValidator.RequiresKey = true
	f.API.CredentialsValidator.RequiresSecret = true

	spot := currency.PairStore{
		RequestFormat: &currency.PairFormat{
			Uppercase: true,
			Delimiter: "/",
		},
		ConfigFormat: &currency.PairFormat{
			Uppercase: true,
			Delimiter: "/",
		},
	}
	futures := currency.PairStore{
		RequestFormat: &currency.PairFormat{
			Uppercase: true,
			Delimiter: "-",
		},
		ConfigFormat: &currency.PairFormat{
			Uppercase: true,
			Delimiter: "-",
		},
	}

	err := f.StoreAssetPairFormat(asset.Spot, spot)
	if err != nil {
		log.Errorln(log.ExchangeSys, err)
	}

	err = f.StoreAssetPairFormat(asset.Futures, futures)
	if err != nil {
		log.Errorln(log.ExchangeSys, err)
	}

	f.Features = exchange.Features{
		Supports: exchange.FeaturesSupported{
			REST:      true,
			Websocket: true,
			RESTCapabilities: protocol.Features{
				TickerFetching:        true,
				TickerBatching:        true,
				KlineFetching:         true,
				TradeFetching:         true,
				OrderbookFetching:     true,
				AutoPairUpdates:       true,
				AccountInfo:           true,
				GetOrder:              true,
				GetOrders:             true,
				CancelOrders:          true,
				CancelOrder:           true,
				SubmitOrder:           true,
				TradeFee:              true,
				FiatDepositFee:        true,
				FiatWithdrawalFee:     true,
				CryptoWithdrawalFee:   true,
				CryptoDeposit:         true,
				CryptoWithdrawal:      true,
				MultiChainDeposits:    true,
				MultiChainWithdrawals: true,
			},
			WebsocketCapabilities: protocol.Features{
				OrderbookFetching: true,
				TradeFetching:     true,
				Subscribe:         true,
				Unsubscribe:       true,
				GetOrders:         true,
				GetOrder:          true,
			},
			WithdrawPermissions: exchange.AutoWithdrawCrypto,
			Kline: kline.ExchangeCapabilitiesSupported{
				DateRanges: true,
				Intervals:  true,
			},
		},
		Enabled: exchange.FeaturesEnabled{
			AutoPairUpdates: true,
			Kline: kline.ExchangeCapabilitiesEnabled{
				Intervals: kline.DeployExchangeIntervals(
					kline.FifteenSecond,
					kline.OneMin,
					kline.FiveMin,
					kline.FifteenMin,
					kline.OneHour,
					kline.FourHour,
					kline.OneDay,
				),
				ResultLimit: 5000,
			},
		},
	}

	f.Requester, err = request.New(f.Name,
		common.NewHTTPClientWithTimeout(exchange.DefaultHTTPTimeout),
		request.WithLimiter(request.NewBasicRateLimit(ratePeriod, rateLimit)))
	if err != nil {
		log.Errorln(log.ExchangeSys, err)
	}
	f.API.Endpoints = f.NewEndpoints()
	err = f.API.Endpoints.SetDefaultEndpoints(map[exchange.URL]string{
		exchange.RestSpot:      ftxAPIURL,
		exchange.WebsocketSpot: ftxWSURL,
	})
	if err != nil {
		log.Errorln(log.ExchangeSys, err)
	}
	f.Websocket = stream.New()
	f.WebsocketResponseMaxLimit = exchange.DefaultWebsocketResponseMaxLimit
	f.WebsocketResponseCheckTimeout = exchange.DefaultWebsocketResponseCheckTimeout
	f.WebsocketOrderbookBufferLimit = exchange.DefaultWebsocketOrderbookBufferLimit

	err = f.LoadCollateralWeightings(context.TODO())
	if err != nil {
		log.Errorf(log.ExchangeSys,
			"%s failed to store collateral weightings. Err: %s",
			f.Name,
			err)
	}
}

// Setup takes in the supplied exchange configuration details and sets params
func (f *FTX) Setup(exch *config.Exchange) error {
	err := exch.Validate()
	if err != nil {
		return err
	}
	if !exch.Enabled {
		f.SetEnabled(false)
		return nil
	}
	err = f.SetupDefaults(exch)
	if err != nil {
		return err
	}

	wsEndpoint, err := f.API.Endpoints.GetURL(exchange.WebsocketSpot)
	if err != nil {
		return err
	}

	err = f.Websocket.Setup(&stream.WebsocketSetup{
		ExchangeConfig:        exch,
		DefaultURL:            ftxWSURL,
		RunningURL:            wsEndpoint,
		Connector:             f.WsConnect,
		Subscriber:            f.Subscribe,
		Unsubscriber:          f.Unsubscribe,
		GenerateSubscriptions: f.GenerateDefaultSubscriptions,
		Features:              &f.Features.Supports.WebsocketCapabilities,
		TradeFeed:             f.Features.Enabled.TradeFeed,
		FillsFeed:             f.Features.Enabled.FillsFeed,
	})
	if err != nil {
		return err
	}

	return f.Websocket.SetupNewConnection(stream.ConnectionSetup{
		ResponseCheckTimeout: exch.WebsocketResponseCheckTimeout,
		ResponseMaxLimit:     exch.WebsocketResponseMaxLimit,
	})
}

// Start starts the FTX go routine
func (f *FTX) Start(wg *sync.WaitGroup) error {
	if wg == nil {
		return fmt.Errorf("%T %w", wg, common.ErrNilPointer)
	}
	wg.Add(1)
	go func() {
		f.Run()
		wg.Done()
	}()
	return nil
}

// Run implements the FTX wrapper
func (f *FTX) Run() {
	if f.Verbose {
		log.Debugf(log.ExchangeSys,
			"%s Websocket: %s.",
			f.Name,
			common.IsEnabled(f.Websocket.IsEnabled()))
		f.PrintEnabledPairs()
	}

	err := f.UpdateOrderExecutionLimits(context.TODO(), asset.Empty)
	if err != nil {
		log.Errorf(log.ExchangeSys,
			"%s failed to set exchange order execution limits. Err: %v",
			f.Name,
			err)
	}

	if !f.GetEnabledFeatures().AutoPairUpdates {
		return
	}

	err = f.UpdateTradablePairs(context.TODO(), false)
	if err != nil {
		log.Errorf(log.ExchangeSys,
			"%s failed to update tradable pairs. Err: %s",
			f.Name,
			err)
	}
}

// FetchTradablePairs returns a list of the exchanges tradable pairs
func (f *FTX) FetchTradablePairs(ctx context.Context, a asset.Item) (currency.Pairs, error) {
	if !f.SupportsAsset(a) {
		return nil, fmt.Errorf("asset type of %s is not supported by %s", a, f.Name)
	}
	markets, err := f.GetMarkets(ctx)
	if err != nil {
		return nil, err
	}
	pairs := make([]currency.Pair, 0, len(markets))
	var pair currency.Pair
	switch a {
	case asset.Spot:
		for x := range markets {
			if markets[x].MarketType != spotString {
				continue
			}
			pair, err = currency.NewPairFromString(markets[x].Name)
			if err != nil {
				return nil, err
			}
			pairs = append(pairs, pair)
		}
	case asset.Futures:
		for x := range markets {
			if markets[x].MarketType != futuresString {
				continue
			}
			pair, err := currency.NewPairFromString(markets[x].Name)
			if err != nil {
				return nil, err
			}
			pairs = append(pairs, pair)
		}
	}
	return pairs, nil
}

// UpdateTradablePairs updates the exchanges available pairs and stores
// them in the exchanges config
func (f *FTX) UpdateTradablePairs(ctx context.Context, forceUpdate bool) error {
	assets := f.GetAssetTypes(false)
	for x := range assets {
		pairs, err := f.FetchTradablePairs(ctx, assets[x])
		if err != nil {
			return err
		}
		err = f.UpdatePairs(pairs, assets[x], false, forceUpdate)
		if err != nil {
			return err
		}
	}
	return nil
}

// UpdateTickers updates the ticker for all currency pairs of a given asset type
func (f *FTX) UpdateTickers(ctx context.Context, a asset.Item) error {
	allPairs, err := f.GetEnabledPairs(a)
	if err != nil {
		return err
	}

	markets, err := f.GetMarkets(ctx)
	if err != nil {
		return err
	}
	for p := range allPairs {
		formattedPair, err := f.FormatExchangeCurrency(allPairs[p], a)
		if err != nil {
			return err
		}

		for x := range markets {
			if markets[x].Name != formattedPair.String() {
				continue
			}
			var resp ticker.Price
			resp.Pair, err = currency.NewPairFromString(markets[x].Name)
			if err != nil {
				return err
			}
			resp.Last = markets[x].Last
			resp.Bid = markets[x].Bid
			resp.Ask = markets[x].Ask
			resp.LastUpdated = time.Now()
			resp.AssetType = a
			resp.ExchangeName = f.Name
			err = ticker.ProcessTicker(&resp)
			if err != nil {
				return err
			}
		}
	}
	return nil
}

// UpdateTicker updates and returns the ticker for a currency pair
func (f *FTX) UpdateTicker(ctx context.Context, p currency.Pair, a asset.Item) (*ticker.Price, error) {
	formattedPair, err := f.FormatExchangeCurrency(p, a)
	if err != nil {
		return nil, err
	}

	market, err := f.GetMarket(ctx, formattedPair.String())
	if err != nil {
		return nil, err
	}

	var resp ticker.Price
	resp.Pair, err = currency.NewPairFromString(market.Name)
	if err != nil {
		return nil, err
	}
	resp.Last = market.Last
	resp.Bid = market.Bid
	resp.Ask = market.Ask
	resp.LastUpdated = time.Now()
	resp.AssetType = a
	resp.ExchangeName = f.Name
	err = ticker.ProcessTicker(&resp)
	if err != nil {
		return nil, err
	}

	return ticker.GetTicker(f.Name, p, a)
}

// FetchTicker returns the ticker for a currency pair
func (f *FTX) FetchTicker(ctx context.Context, p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
	tickerNew, err := ticker.GetTicker(f.Name, p, assetType)
	if err != nil {
		return f.UpdateTicker(ctx, p, assetType)
	}
	return tickerNew, nil
}

// FetchOrderbook returns orderbook base on the currency pair
func (f *FTX) FetchOrderbook(ctx context.Context, c currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
	ob, err := orderbook.Get(f.Name, c, assetType)
	if err != nil {
		return f.UpdateOrderbook(ctx, c, assetType)
	}
	return ob, nil
}

// UpdateOrderbook updates and returns the orderbook for a currency pair
func (f *FTX) UpdateOrderbook(ctx context.Context, p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
	book := &orderbook.Base{
		Exchange:        f.Name,
		Pair:            p,
		Asset:           assetType,
		VerifyOrderbook: f.CanVerifyOrderbook,
	}
	formattedPair, err := f.FormatExchangeCurrency(p, assetType)
	if err != nil {
		return book, err
	}
	tempResp, err := f.GetOrderbook(ctx, formattedPair.String(), 100)
	if err != nil {
		return book, err
	}

	book.Bids = make(orderbook.Items, 0, len(tempResp.Bids))
	for x := range tempResp.Bids {
		// Bear tokens have illiquid books and contain negative place holders.
		if tempResp.Bids[x].Size < 0 && strings.Contains(p.String(), "BEAR") {
			continue
		}
		book.Bids = append(book.Bids, orderbook.Item{
			Amount: tempResp.Bids[x].Size,
			Price:  tempResp.Bids[x].Price,
		})
	}
	book.Asks = make(orderbook.Items, 0, len(tempResp.Asks))
	for y := range tempResp.Asks {
		// Bear tokens have illiquid books and contain negative place holders.
		if tempResp.Asks[y].Size < 0 && strings.Contains(p.String(), "BEAR") {
			continue
		}
		book.Asks = append(book.Asks, orderbook.Item{
			Amount: tempResp.Asks[y].Size,
			Price:  tempResp.Asks[y].Price,
		})
	}
	err = book.Process()
	if err != nil {
		return book, err
	}
	return orderbook.Get(f.Name, p, assetType)
}

// UpdateAccountInfo retrieves balances for all enabled currencies
func (f *FTX) UpdateAccountInfo(ctx context.Context, a asset.Item) (account.Holdings, error) {
	creds, err := f.GetCredentials(ctx)
	if err != nil {
		return account.Holdings{}, err
	}
	var resp account.Holdings

	var data AllWalletBalances
	if creds.SubAccount != "" {
		balances, err := f.GetBalances(ctx, false, false)
		if err != nil {
			return resp, err
		}
		data = make(AllWalletBalances)
		data[creds.SubAccount] = balances
	} else {
		// Get all wallet balances used so we can transfer between accounts if
		// needed.
		var err error
		data, err = f.GetAllWalletBalances(ctx)
		if err != nil {
			return resp, err
		}
	}
	for subName, balances := range data {
		// "main" defines the main account in the sub account list
		var acc = account.SubAccount{ID: subName, AssetType: a}
		for x := range balances {
			// the Free field includes borrow amount with available holdings
			// Using AvailableWithoutBorrow allows for a more accurate picture of balance
			hold := balances[x].Total - balances[x].AvailableWithoutBorrow
			acc.Currencies = append(acc.Currencies,
				account.Balance{
					Currency:               balances[x].Coin,
					Total:                  balances[x].Total,
					Hold:                   hold,
					AvailableWithoutBorrow: balances[x].AvailableWithoutBorrow,
					Borrowed:               balances[x].SpotBorrow,
					Free:                   balances[x].Free,
				})
		}
		resp.Accounts = append(resp.Accounts, acc)
	}

	resp.Exchange = f.Name
	if err := account.Process(&resp, creds); err != nil {
		return account.Holdings{}, err
	}

	return resp, nil
}

// FetchAccountInfo retrieves balances for all enabled currencies
func (f *FTX) FetchAccountInfo(ctx context.Context, assetType asset.Item) (account.Holdings, error) {
	creds, err := f.GetCredentials(ctx)
	if err != nil {
		return account.Holdings{}, err
	}
	acc, err := account.GetHoldings(f.Name, creds, assetType)
	if err != nil {
		return f.UpdateAccountInfo(ctx, assetType)
	}
	return acc, nil
}

// GetFundingHistory returns funding history, deposits and
// withdrawals
func (f *FTX) GetFundingHistory(ctx context.Context) ([]exchange.FundHistory, error) {
	depositData, err := f.FetchDepositHistory(ctx)
	if err != nil {
		return nil, err
	}
	withdrawalData, err := f.FetchWithdrawalHistory(ctx)
	if err != nil {
		return nil, err
	}
	fundingData := make([]exchange.FundHistory, 0, len(depositData)+len(withdrawalData))
	for x := range depositData {
		fundingData = append(fundingData, exchange.FundHistory{
			Fee:             depositData[x].Fee,
			Timestamp:       depositData[x].Time,
			ExchangeName:    f.Name,
			CryptoToAddress: depositData[x].Address.Address,
			CryptoTxID:      depositData[x].TxID,
			CryptoChain:     depositData[x].Address.Method,
			Status:          depositData[x].Status,
			Amount:          depositData[x].Size,
			Currency:        depositData[x].Coin,
			TransferID:      strconv.FormatInt(depositData[x].ID, 10),
		})
	}
	for y := range withdrawalData {
		fundingData = append(fundingData, exchange.FundHistory{
			Fee:             withdrawalData[y].Fee,
			Timestamp:       withdrawalData[y].Time,
			ExchangeName:    f.Name,
			CryptoToAddress: withdrawalData[y].Address,
			CryptoTxID:      withdrawalData[y].TXID,
			CryptoChain:     withdrawalData[y].Method,
			Status:          withdrawalData[y].Status,
			Amount:          withdrawalData[y].Size,
			Currency:        withdrawalData[y].Coin,
			TransferID:      strconv.FormatInt(withdrawalData[y].ID, 10),
		})
	}
	return fundingData, nil
}

// GetWithdrawalsHistory returns previous withdrawals data
func (f *FTX) GetWithdrawalsHistory(ctx context.Context, c currency.Code, _ asset.Item) (resp []exchange.WithdrawalHistory, err error) {
	return nil, common.ErrNotYetImplemented
}

// GetRecentTrades returns the most recent trades for a currency and asset
func (f *FTX) GetRecentTrades(ctx context.Context, p currency.Pair, assetType asset.Item) ([]trade.Data, error) {
	return f.GetHistoricTrades(ctx, p, assetType, time.Now().Add(-time.Minute*15), time.Now())
}

// GetHistoricTrades returns historic trade data within the timeframe provided
// FTX returns trades from the end date and iterates towards the start date
func (f *FTX) GetHistoricTrades(ctx context.Context, p currency.Pair, assetType asset.Item, timestampStart, timestampEnd time.Time) ([]trade.Data, error) {
	if err := common.StartEndTimeCheck(timestampStart, timestampEnd); err != nil {
		return nil, fmt.Errorf("invalid time range supplied. Start: %v End %v %w", timestampStart, timestampEnd, err)
	}
	var err error
	p, err = f.FormatExchangeCurrency(p, assetType)
	if err != nil {
		return nil, err
	}

	endTime := timestampEnd
	var resp []trade.Data
allTrades:
	for {
		var trades []TradeData
		trades, err = f.GetTrades(ctx,
			p.String(),
			timestampStart.Unix(),
			endTime.Unix(),
			0)
		if err != nil {
			if errors.Is(err, errStartTimeCannotBeAfterEndTime) {
				break
			}
			return nil, err
		}
		if len(trades) == 0 {
			break
		}
		for i := 0; i < len(trades); i++ {
			if timestampStart.Equal(trades[i].Time) || trades[i].Time.Before(timestampStart) {
				// reached end of trades to crawl
				break allTrades
			}
			if trades[i].Time.After(endTime) {
				continue
			}
			var side order.Side
			side, err = order.StringToOrderSide(trades[i].Side)
			if err != nil {
				return nil, err
			}
			resp = append(resp, trade.Data{
				TID:          strconv.FormatInt(trades[i].ID, 10),
				Exchange:     f.Name,
				CurrencyPair: p,
				AssetType:    assetType,
				Side:         side,
				Price:        trades[i].Price,
				Amount:       trades[i].Size,
				Timestamp:    trades[i].Time,
			})
		}
		endTime = trades[len(trades)-1].Time
	}

	err = f.AddTradesToBuffer(resp...)
	if err != nil {
		return nil, err
	}

	sort.Sort(trade.ByDate(resp))
	return trade.FilterTradesByTime(resp, timestampStart, timestampEnd), nil
}

// SubmitOrder submits a new order
func (f *FTX) SubmitOrder(ctx context.Context, s *order.Submit) (*order.SubmitResponse, error) {
	if err := s.Validate(); err != nil {
		return nil, err
	}

	if s.Side.IsShort() {
		s.Side = order.Sell
	}
	if s.Side.IsLong() {
		s.Side = order.Buy
	}

	fPair, err := f.FormatExchangeCurrency(s.Pair, s.AssetType)
	if err != nil {
		return nil, err
	}

	tempResp, err := f.Order(ctx,
		fPair.String(),
		s.Side.Lower(),
		s.Type.Lower(),
		s.ReduceOnly,
		s.ImmediateOrCancel,
		s.PostOnly,
		s.ClientOrderID,
		s.Price,
		s.Amount)
	if err != nil {
		return nil, err
	}

	resp, err := s.DeriveSubmitResponse(strconv.FormatInt(tempResp.ID, 10))
	if err != nil {
		return nil, err
	}
	if !s.RetrieveFees {
		return resp, nil
	}
	time.Sleep(s.RetrieveFeeDelay)
	fills, err := f.GetFills(ctx, s.Pair, s.AssetType, time.Time{}, time.Time{}, strconv.FormatInt(tempResp.ID, 10))
	if err != nil {
		// choosing to return with no error so that a valid order is still returned to caller
		log.Errorf(log.ExchangeSys, "could not retrieve fees for order %v: %v", tempResp.ID, err)
		return resp, nil
	}
	for i := range fills {
		resp.Fee += fills[i].Fee
		var side order.Side
		side, err = order.StringToOrderSide(fills[i].Side)
		if err != nil {
			return nil, err
		}
		if resp.FeeAsset.IsEmpty() {
			resp.FeeAsset = fills[i].FeeCurrency
		}
		resp.Trades = append(resp.Trades, order.TradeHistory{
			Price:     fills[i].Price,
			Amount:    fills[i].Size,
			Fee:       fills[i].Fee,
			Exchange:  f.Name,
			TID:       strconv.FormatInt(fills[i].TradeID, 10),
			Side:      side,
			Timestamp: fills[i].Time,
			IsMaker:   fills[i].Liquidity == "maker",
			FeeAsset:  fills[i].FeeCurrency.String(),
		})
	}
	return resp, nil
}

// ModifyOrder will allow of changing orderbook placement and limit to
// market conversion
func (f *FTX) ModifyOrder(ctx context.Context, action *order.Modify) (*order.ModifyResponse, error) {
	if err := action.Validate(); err != nil {
		return nil, err
	}

	var id string
	var remainingAmount float64
	switch {
	case action.TriggerPrice != 0:
		var a TriggerOrderData
		a, err := f.ModifyTriggerOrder(ctx,
			action.OrderID,
			action.Type.String(),
			action.Amount,
			action.TriggerPrice,
			action.Price,
			0)
		if err != nil {
			return nil, err
		}
		id = strconv.FormatInt(a.ID, 10)
		remainingAmount = a.Size - a.FilledSize
	case action.OrderID == "":
		o, err := f.ModifyOrderByClientID(ctx,
			action.ClientOrderID,
			action.ClientOrderID,
			action.Price,
			action.Amount)
		if err != nil {
			return nil, err
		}
		id = strconv.FormatInt(o.ID, 10)
		remainingAmount = o.RemainingSize
	default:
		o, err := f.ModifyPlacedOrder(ctx,
			action.OrderID,
			action.ClientOrderID,
			action.Price,
			action.Amount)
		if err != nil {
			return nil, err
		}
		id = strconv.FormatInt(o.ID, 10)
		remainingAmount = o.RemainingSize
	}
	resp, err := action.DeriveModifyResponse()
	if err != nil {
		return nil, err
	}
	resp.OrderID = id
	resp.RemainingAmount = remainingAmount
	return resp, nil
}

// CancelOrder cancels an order by its corresponding ID number
func (f *FTX) CancelOrder(ctx context.Context, o *order.Cancel) error {
	if err := o.Validate(o.StandardCancel()); err != nil {
		return err
	}

	if o.ClientOrderID != "" {
		_, err := f.DeleteOrderByClientID(ctx, o.ClientOrderID)
		return err
	}

	_, err := f.DeleteOrder(ctx, o.OrderID)
	return err
}

// CancelBatchOrders cancels an orders by their corresponding ID numbers
func (f *FTX) CancelBatchOrders(ctx context.Context, o []order.Cancel) (order.CancelBatchResponse, error) {
	return order.CancelBatchResponse{}, common.ErrNotYetImplemented
}

// CancelAllOrders cancels all orders associated with a currency pair
func (f *FTX) CancelAllOrders(ctx context.Context, orderCancellation *order.Cancel) (order.CancelAllResponse, error) {
	if err := orderCancellation.Validate(); err != nil {
		return order.CancelAllResponse{}, err
	}

	var resp order.CancelAllResponse
	formattedPair, err := f.FormatExchangeCurrency(orderCancellation.Pair, orderCancellation.AssetType)
	if err != nil {
		return resp, err
	}
	orders, err := f.GetOpenOrders(ctx, formattedPair.String())
	if err != nil {
		return resp, err
	}

	tempMap := make(map[string]string)
	for x := range orders {
		_, err := f.DeleteOrder(ctx, strconv.FormatInt(orders[x].ID, 10))
		if err != nil {
			tempMap[strconv.FormatInt(orders[x].ID, 10)] = "Cancellation Failed"
			continue
		}
		tempMap[strconv.FormatInt(orders[x].ID, 10)] = "Success"
	}
	resp.Status = tempMap
	return resp, nil
}

// GetCompatible gets compatible variables for order vars
func (s *OrderData) GetCompatible(ctx context.Context, f *FTX) (OrderVars, error) {
	var resp OrderVars
	switch s.Side {
	case order.Buy.Lower():
		resp.Side = order.Buy
	case order.Sell.Lower():
		resp.Side = order.Sell
	default:
		resp.Side = order.UnknownSide
	}
	switch s.Status {
	case strings.ToLower(order.New.String()):
		resp.Status = order.New
	case strings.ToLower(order.Open.String()):
		resp.Status = order.Open
	case closedStatus:
		if s.FilledSize != 0 && s.FilledSize != s.Size {
			resp.Status = order.PartiallyCancelled
		}
		if s.FilledSize == 0 {
			resp.Status = order.Cancelled
		}
		if s.FilledSize == s.Size {
			resp.Status = order.Filled
		}
	default:
		resp.Status = order.AnyStatus
	}
	var feeBuilder exchange.FeeBuilder
	feeBuilder.PurchasePrice = s.AvgFillPrice
	feeBuilder.Amount = s.Size
	resp.OrderType = order.Market
	if strings.EqualFold(s.Type, order.Limit.String()) {
		resp.OrderType = order.Limit
		feeBuilder.IsMaker = true
	}
	fee, err := f.GetFee(ctx, &feeBuilder)
	if err != nil {
		return resp, err
	}
	resp.Fee = fee
	return resp, nil
}

// GetOrderInfo returns order information based on order ID
func (f *FTX) GetOrderInfo(ctx context.Context, orderID string, _ currency.Pair, _ asset.Item) (order.Detail, error) {
	var resp order.Detail
	orderData, err := f.GetOrderStatus(ctx, orderID)
	if err != nil {
		return resp, err
	}
	orderAssetType, err := f.GetPairAssetType(orderData.Market)
	if err != nil {
		return resp, err
	}
	resp.OrderID = strconv.FormatInt(orderData.ID, 10)
	resp.Amount = orderData.Size
	resp.ClientOrderID = orderData.ClientID
	resp.Date = orderData.CreatedAt
	resp.Exchange = f.Name
	resp.ExecutedAmount = orderData.Size - orderData.RemainingSize
	resp.Pair = orderData.Market
	resp.AssetType = orderAssetType
	resp.Price = orderData.Price
	resp.RemainingAmount = orderData.RemainingSize
	orderVars, err := orderData.GetCompatible(ctx, f)
	if err != nil {
		return resp, err
	}
	resp.Status = orderVars.Status
	resp.Side = orderVars.Side
	resp.Type = orderVars.OrderType
	resp.Fee = orderVars.Fee
	return resp, nil
}

// GetDepositAddress returns a deposit address for a specified currency
func (f *FTX) GetDepositAddress(ctx context.Context, cryptocurrency currency.Code, _, chain string) (*deposit.Address, error) {
	a, err := f.FetchDepositAddress(ctx, cryptocurrency, chain)
	if err != nil {
		return nil, err
	}
	return &deposit.Address{
		Address: a.Address,
		Tag:     a.Tag,
	}, nil
}

// WithdrawCryptocurrencyFunds returns a withdrawal ID when a withdrawal is
// submitted
func (f *FTX) WithdrawCryptocurrencyFunds(ctx context.Context, withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error) {
	if err := withdrawRequest.Validate(); err != nil {
		return nil, err
	}
	resp, err := f.Withdraw(ctx,
		withdrawRequest.Currency,
		withdrawRequest.Crypto.Address,
		withdrawRequest.Crypto.AddressTag,
		withdrawRequest.TradePassword,
		withdrawRequest.Crypto.Chain,
		strconv.FormatInt(withdrawRequest.OneTimePassword, 10),
		withdrawRequest.Amount)
	if err != nil {
		return nil, err
	}

	return &withdraw.ExchangeResponse{
		ID:     strconv.FormatInt(resp.ID, 10),
		Status: resp.Status,
	}, nil
}

// WithdrawFiatFunds returns a withdrawal ID when a withdrawal is
// submitted
func (f *FTX) WithdrawFiatFunds(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
	return nil, common.ErrFunctionNotSupported
}

// WithdrawFiatFundsToInternationalBank returns a withdrawal ID when a
// withdrawal is submitted
func (f *FTX) WithdrawFiatFundsToInternationalBank(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
	return nil, common.ErrFunctionNotSupported
}

// GetWebsocket returns a pointer to the exchange websocket
func (f *FTX) GetWebsocket() (*stream.Websocket, error) {
	return f.Websocket, nil
}

// GetActiveOrders retrieves any orders that are active/open
func (f *FTX) GetActiveOrders(ctx context.Context, request *order.GetOrdersRequest) (order.FilteredOrders, error) {
	err := request.Validate(validTypes{request})
	if err != nil {
		return nil, err
	}

	var resp []order.Detail
	for x := range request.Pairs {
		var assetType asset.Item
		assetType, err = f.GetPairAssetType(request.Pairs[x])
		if err != nil {
			return resp, err
		}

		var fPair currency.Pair
		fPair, err = f.FormatExchangeCurrency(request.Pairs[x], assetType)
		if err != nil {
			return nil, err
		}

		var tempResp order.Detail
		if request.Type == order.AnyType ||
			request.Type == order.Limit ||
			request.Type == order.Market {
			orderData, err := f.GetOpenOrders(ctx, fPair.String())
			if err != nil {
				return resp, err
			}
			for y := range orderData {
				tempResp.OrderID = strconv.FormatInt(orderData[y].ID, 10)
				tempResp.Amount = orderData[y].Size
				tempResp.AssetType = assetType
				tempResp.ClientOrderID = orderData[y].ClientID
				tempResp.Date = orderData[y].CreatedAt
				tempResp.Exchange = f.Name
				tempResp.ExecutedAmount = orderData[y].Size - orderData[y].RemainingSize
				tempResp.Pair = orderData[y].Market
				tempResp.Price = orderData[y].Price
				tempResp.RemainingAmount = orderData[y].RemainingSize
				var orderVars OrderVars
				orderVars, err = f.compatibleOrderVars(ctx,
					orderData[y].Side,
					orderData[y].Status,
					orderData[y].Type,
					orderData[y].Size,
					orderData[y].FilledSize,
					orderData[y].AvgFillPrice)
				if err != nil {
					return resp, err
				}
				tempResp.Status = orderVars.Status
				tempResp.Side = orderVars.Side
				tempResp.Type = orderVars.OrderType
				tempResp.Fee = orderVars.Fee
				resp = append(resp, tempResp)
			}
		}

		if request.Type != order.AnyType &&
			request.Type != order.Stop &&
			request.Type != order.TrailingStop &&
			request.Type != order.TakeProfit {
			continue
		}

		var t string
		if request.Type != order.AnyType {
			t = request.Type.Lower()
		}

		triggerOrderData, err := f.GetOpenTriggerOrders(ctx, fPair.String(), t)
		if err != nil {
			return resp, err
		}
		for z := range triggerOrderData {
			var p currency.Pair
			p, err = currency.NewPairFromString(triggerOrderData[z].Market)
			if err != nil {
				return nil, err
			}
			tempResp.OrderID = strconv.FormatInt(triggerOrderData[z].ID, 10)
			tempResp.Amount = triggerOrderData[z].Size
			tempResp.AssetType = assetType
			tempResp.Date = triggerOrderData[z].CreatedAt
			tempResp.Exchange = f.Name
			tempResp.ExecutedAmount = triggerOrderData[z].FilledSize
			tempResp.Pair = p
			tempResp.Price = triggerOrderData[z].AvgFillPrice
			tempResp.RemainingAmount = triggerOrderData[z].Size - triggerOrderData[z].FilledSize
			tempResp.TriggerPrice = triggerOrderData[z].TriggerPrice
			orderVars, err := f.compatibleOrderVars(ctx,
				triggerOrderData[z].Side,
				triggerOrderData[z].Status,
				triggerOrderData[z].OrderType,
				triggerOrderData[z].Size,
				triggerOrderData[z].FilledSize,
				triggerOrderData[z].AvgFillPrice)
			if err != nil {
				return resp, err
			}
			tempResp.Status = orderVars.Status
			tempResp.Side = orderVars.Side
			tempResp.Type = orderVars.OrderType
			tempResp.Fee = orderVars.Fee
			resp = append(resp, tempResp)
		}
	}
	return request.Filter(f.Name, resp), nil
}

// GetOrderHistory retrieves account order information
// Can Limit response to specific order status
func (f *FTX) GetOrderHistory(ctx context.Context, request *order.GetOrdersRequest) (order.FilteredOrders, error) {
	err := request.Validate(validTypes{request}, validSides{request})
	if err != nil {
		return nil, err
	}
	var resp []order.Detail
	for x := range request.Pairs {
		var d order.Detail
		fp, err := f.FormatExchangeCurrency(request.Pairs[x], request.AssetType)
		if err != nil {
			return nil, err
		}

		if request.Type == order.AnyType ||
			request.Type == order.Limit ||
			request.Type == order.Market {
			var history []OrderData
			history, err = f.FetchOrderHistory(ctx,
				fp.String(),
				request.StartTime,
				request.EndTime,
				"")
			if err != nil {
				return nil, err
			}
			for y := range history {
				d.OrderID = strconv.FormatInt(history[y].ID, 10)
				d.Amount = history[y].Size
				d.AssetType = request.AssetType
				d.AverageExecutedPrice = history[y].AvgFillPrice
				d.ClientOrderID = history[y].ClientID
				d.Date = history[y].CreatedAt
				d.Exchange = f.Name
				d.ExecutedAmount = history[y].Size - history[y].RemainingSize
				d.Pair = history[y].Market
				d.Price = history[y].Price
				d.RemainingAmount = history[y].RemainingSize
				var orderVars OrderVars
				orderVars, err = f.compatibleOrderVars(ctx,
					history[y].Side,
					history[y].Status,
					history[y].Type,
					history[y].Size,
					history[y].FilledSize,
					history[y].AvgFillPrice)
				if err != nil {
					return resp, err
				}
				d.Status = orderVars.Status
				d.Side = orderVars.Side
				d.Type = orderVars.OrderType
				d.Fee = orderVars.Fee
				resp = append(resp, d)
			}
		}

		if request.Type != order.AnyType &&
			request.Type != order.Stop &&
			request.Type != order.TrailingStop &&
			request.Type != order.TakeProfit {
			continue
		}

		var side string
		if request.Side != order.AnySide {
			side = request.Side.Lower()
		}

		var t string
		if request.Type != order.AnyType {
			t = request.Type.Lower()
		}

		triggerOrderData, err := f.GetTriggerOrderHistory(ctx,
			fp.String(),
			request.StartTime,
			request.EndTime,
			side,
			t,
			"")
		if err != nil {
			return nil, err
		}
		for z := range triggerOrderData {
			var p currency.Pair
			p, err = currency.NewPairFromString(triggerOrderData[z].Market)
			if err != nil {
				return nil, err
			}
			d.OrderID = strconv.FormatInt(triggerOrderData[z].ID, 10)
			d.Amount = triggerOrderData[z].Size
			d.AssetType = request.AssetType
			d.Date = triggerOrderData[z].CreatedAt
			d.Exchange = f.Name
			d.ExecutedAmount = triggerOrderData[z].FilledSize
			d.Pair = p
			d.Price = triggerOrderData[z].AvgFillPrice
			d.RemainingAmount = triggerOrderData[z].Size - triggerOrderData[z].FilledSize
			d.TriggerPrice = triggerOrderData[z].TriggerPrice
			var orderVars OrderVars
			orderVars, err = f.compatibleOrderVars(ctx,
				triggerOrderData[z].Side,
				triggerOrderData[z].Status,
				triggerOrderData[z].OrderType,
				triggerOrderData[z].Size,
				triggerOrderData[z].FilledSize,
				triggerOrderData[z].AvgFillPrice)
			if err != nil {
				return nil, err
			}
			d.Status = orderVars.Status
			d.Side = orderVars.Side
			d.Type = orderVars.OrderType
			d.Fee = orderVars.Fee
			d.InferCostsAndTimes()
			resp = append(resp, d)
		}
	}
	return request.Filter(f.Name, resp), nil
}

// GetFeeByType returns an estimate of fee based on the type of transaction
func (f *FTX) GetFeeByType(ctx context.Context, feeBuilder *exchange.FeeBuilder) (float64, error) {
	if feeBuilder == nil {
		return 0, fmt.Errorf("%T %w", feeBuilder, common.ErrNilPointer)
	}
	return f.GetFee(ctx, feeBuilder)
}

// SubscribeToWebsocketChannels appends to ChannelsToSubscribe
// which lets websocket.manageSubscriptions handle subscribing
func (f *FTX) SubscribeToWebsocketChannels(channels []stream.ChannelSubscription) error {
	return f.Websocket.SubscribeToChannels(channels)
}

// UnsubscribeToWebsocketChannels removes from ChannelsToSubscribe
// which lets websocket.manageSubscriptions handle unsubscribing
func (f *FTX) UnsubscribeToWebsocketChannels(channels []stream.ChannelSubscription) error {
	return f.Websocket.UnsubscribeChannels(channels)
}

// AuthenticateWebsocket sends an authentication message to the websocket
func (f *FTX) AuthenticateWebsocket(ctx context.Context) error {
	return f.WsAuth(ctx)
}

// ValidateCredentials validates current credentials used for wrapper
// functionality
func (f *FTX) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
	_, err := f.UpdateAccountInfo(ctx, assetType)
	return f.CheckTransientError(err)
}

// GetHistoricCandles returns candles between a time period for a set time interval
func (f *FTX) GetHistoricCandles(ctx context.Context, pair currency.Pair, a asset.Item, interval kline.Interval, start, end time.Time) (*kline.Item, error) {
	req, err := f.GetKlineRequest(pair, a, interval, start, end)
	if err != nil {
		return nil, err
	}

	ohlcData, err := f.GetHistoricalData(ctx,
		req.RequestFormatted.String(),
		int64(req.ExchangeInterval.Duration().Seconds()),
		int64(f.Features.Enabled.Kline.ResultLimit),
		req.Start,
		req.End)
	if err != nil {
		return nil, err
	}

	timeSeries := make([]kline.Candle, len(ohlcData))
	for x := range ohlcData {
		timeSeries[x] = kline.Candle{
			Time:   ohlcData[x].StartTime,
			Open:   ohlcData[x].Open,
			High:   ohlcData[x].High,
			Low:    ohlcData[x].Low,
			Close:  ohlcData[x].Close,
			Volume: ohlcData[x].Volume,
		}
	}
	return req.ProcessResponse(timeSeries)
}

// GetHistoricCandlesExtended returns candles between a time period for a set time interval
func (f *FTX) GetHistoricCandlesExtended(ctx context.Context, pair currency.Pair, a asset.Item, interval kline.Interval, start, end time.Time) (*kline.Item, error) {
	req, err := f.GetKlineExtendedRequest(pair, a, interval, start, end)
	if err != nil {
		return nil, err
	}

	timeSeries := make([]kline.Candle, 0, req.Size())
	for x := range req.RangeHolder.Ranges {
		var ohlcData []OHLCVData
		ohlcData, err = f.GetHistoricalData(ctx,
			req.RequestFormatted.String(),
			int64(req.ExchangeInterval.Duration().Seconds()),
			int64(f.Features.Enabled.Kline.ResultLimit),
			req.RangeHolder.Ranges[x].Start.Time,
			req.RangeHolder.Ranges[x].End.Time)
		if err != nil {
			return nil, err
		}

		for i := range ohlcData {
			timeSeries = append(timeSeries, kline.Candle{
				Time:   ohlcData[i].StartTime,
				Open:   ohlcData[i].Open,
				High:   ohlcData[i].High,
				Low:    ohlcData[i].Low,
				Close:  ohlcData[i].Close,
				Volume: ohlcData[i].Volume,
			})
		}
	}
	return req.ProcessResponse(timeSeries)
}

// UpdateOrderExecutionLimits sets exchange executions for a required asset type
func (f *FTX) UpdateOrderExecutionLimits(ctx context.Context, _ asset.Item) error {
	limits, err := f.FetchExchangeLimits(ctx)
	if err != nil {
		return fmt.Errorf("cannot update exchange execution limits: %w", err)
	}
	return f.LoadLimits(limits)
}

// GetAvailableTransferChains returns the available transfer blockchains for the specific
// cryptocurrency
func (f *FTX) GetAvailableTransferChains(ctx context.Context, cryptocurrency currency.Code) ([]string, error) {
	coins, err := f.GetCoins(ctx)
	if err != nil {
		return nil, err
	}

	var availableChains []string
	for x := range coins {
		if strings.EqualFold(coins[x].ID, cryptocurrency.String()) {
			for y := range coins[x].Methods {
				availableChains = append(availableChains, coins[x].Methods[y])
			}
		}
	}
	return availableChains, nil
}

// CalculatePNL determines the PNL of a given position based on the PNLCalculatorRequest
func (f *FTX) CalculatePNL(ctx context.Context, pnl *order.PNLCalculatorRequest) (*order.PNLResult, error) {
	if pnl == nil {
		return nil, fmt.Errorf("%v %w", f.Name, order.ErrNilPNLCalculator)
	}
	result := &order.PNLResult{
		Time:    pnl.Time,
		IsOrder: true,
	}
	creds, err := f.GetCredentials(ctx)
	if err != nil {
		return nil, err
	}
	if pnl.CalculateOffline {
		// PNLCalculator matches FTX's pnl calculation method
		calc := order.PNLCalculator{}
		result, err = calc.CalculatePNL(ctx, pnl)
		if err != nil {
			return nil, fmt.Errorf("%s %s %w", f.Name, creds.SubAccount, err)
		}
	}

	ep := pnl.EntryPrice.InexactFloat64()
	info, err := f.GetAccountInfo(ctx)
	if err != nil {
		return nil, err
	}
	if info.Liquidating || info.Collateral <= 0 {
		result.IsLiquidated = true
		return result, fmt.Errorf("%s %s %w", f.Name, creds.SubAccount, order.ErrPositionLiquidated)
	}
	for i := range info.Positions {
		if !pnl.Pair.Equal(info.Positions[i].Future) {
			continue
		}
		if info.Positions[i].EntryPrice != ep {
			continue
		}
		result.UnrealisedPNL = decimal.NewFromFloat(info.Positions[i].UnrealizedPNL)
		result.RealisedPNLBeforeFees = decimal.NewFromFloat(info.Positions[i].RealizedPNL)
		result.Price = decimal.NewFromFloat(info.Positions[i].Cost)
		return result, nil
	}
	// order no longer active, use offline calculation
	calc := order.PNLCalculator{}
	result, err = calc.CalculatePNL(ctx, pnl)
	if err != nil {
		return nil, fmt.Errorf("%s %s %w", f.Name, creds.SubAccount, err)
	}
	return result, nil
}

// ScaleCollateral takes your totals and scales them according to FTX's rules
func (f *FTX) ScaleCollateral(ctx context.Context, calc *order.CollateralCalculator) (*order.CollateralByCurrency, error) {
	if calc.CalculateOffline {
		result := &order.CollateralByCurrency{
			Currency:                    calc.CollateralCurrency,
			TotalFunds:                  calc.FreeCollateral.Add(calc.LockedCollateral),
			AvailableForUseAsCollateral: calc.FreeCollateral,
			FairMarketValue:             calc.USDPrice,
			ScaledCurrency:              currency.USD,
			UnrealisedPNL:               calc.UnrealisedPNL,
			ScaledUsed:                  calc.LockedCollateral,
		}
		if calc.CollateralCurrency.Equal(currency.USD) {
			// FTX bases scales all collateral into USD amounts
			result.CollateralContribution = calc.FreeCollateral
			result.Weighting = decimal.NewFromInt(1)
			result.FairMarketValue = decimal.NewFromInt(1)
			return result, nil
		}
		result.ScaledCurrency = currency.USD
		if calc.USDPrice.IsZero() {
			return nil, fmt.Errorf("%s %s %w to scale collateral", f.Name, calc.CollateralCurrency, order.ErrUSDValueRequired)
		}
		if calc.FreeCollateral.IsZero() && calc.LockedCollateral.IsZero() {
			return result, nil
		}
		collateralWeight, ok := f.collateralWeight[calc.CollateralCurrency.Item]
		if !ok {
			return nil, fmt.Errorf("%s %s %w", f.Name, calc.CollateralCurrency, errCollateralCurrencyNotFound)
		}
		if calc.FreeCollateral.IsPositive() {
			if collateralWeight.InitialMarginFractionFactor == 0 {
				return nil, fmt.Errorf("%s %s %w", f.Name, calc.CollateralCurrency, errCollateralInitialMarginFractionMissing)
			}
			var scaling decimal.Decimal
			if calc.IsForNewPosition {
				scaling = decimal.NewFromFloat(collateralWeight.Initial)
			} else {
				scaling = decimal.NewFromFloat(collateralWeight.Total)
			}
			if scaling.IsZero() {
				result.SkipContribution = true
			}
			result.Weighting = scaling
			one := decimal.NewFromInt(1)
			freeSqrt := decimal.NewFromFloat(math.Sqrt(calc.FreeCollateral.InexactFloat64()))
			lockedSqrt := decimal.NewFromFloat(math.Sqrt(calc.LockedCollateral.InexactFloat64()))
			onePointOne := decimal.NewFromFloat(1.1)
			imf := decimal.NewFromFloat(collateralWeight.InitialMarginFractionFactor)
			freeWeight := onePointOne.Div(one.Add(imf.Mul(freeSqrt)))
			lockedWeight := onePointOne.Div(one.Add(imf.Mul(lockedSqrt)))
			result.CollateralContribution = calc.FreeCollateral.Mul(calc.USDPrice).Mul(decimal.Min(scaling, freeWeight))
			result.ScaledUsed = calc.LockedCollateral.Mul(calc.USDPrice).Mul(decimal.Min(scaling, lockedWeight))
		} else {
			result.CollateralContribution = calc.FreeCollateral.Mul(calc.USDPrice)
			result.ScaledUsed = calc.LockedCollateral.Mul(calc.USDPrice)
		}

		if !result.UnrealisedPNL.IsZero() && result.ScaledUsedBreakdown != nil {
			result.CollateralContribution = decimal.Min(result.CollateralContribution, result.CollateralContribution.Sub(result.UnrealisedPNL)).Sub(result.ScaledUsedBreakdown.LockedAsCollateral)
		}

		return result, nil
	}
	resp, err := f.calculateTotalCollateralOnline(ctx,
		&order.TotalCollateralCalculator{
			CollateralAssets: []order.CollateralCalculator{*calc},
		},
		nil,
	)
	if err != nil {
		return nil, err
	}
	if len(resp.BreakdownByCurrency) == 0 {
		return nil, fmt.Errorf("%v %v %w", f.Name, calc.CollateralCurrency, errCollateralCurrencyNotFound)
	}
	return &resp.BreakdownByCurrency[0], nil
}

// CalculateTotalCollateral scales collateral and determines how much collateral you can use for positions
func (f *FTX) CalculateTotalCollateral(ctx context.Context, calc *order.TotalCollateralCalculator) (*order.TotalCollateralResponse, error) {
	if calc == nil {
		return nil, fmt.Errorf("%v CalculateTotalCollateral %w", f.Name, common.ErrNilPointer)
	}
	var pos []PositionData
	var err error
	if calc.FetchPositions {
		pos, err = f.GetPositions(ctx, true)
		if err != nil {
			return nil, fmt.Errorf("%v CalculateTotalCollateral GetPositions %w", f.Name, err)
		}
	}
	if !calc.CalculateOffline {
		return f.calculateTotalCollateralOnline(ctx, calc, pos)
	}

	result := order.TotalCollateralResponse{
		CollateralCurrency: currency.USD,
	}
	for i := range calc.CollateralAssets {
		if len(pos) > 0 {
			// ensure we use supplied position data
			calc.CollateralAssets[i].UnrealisedPNL = decimal.Zero
			for j := range pos {
				if !pos[j].Future.Base.Equal(calc.CollateralAssets[i].CollateralCurrency) {
					continue
				}
				calc.CollateralAssets[i].UnrealisedPNL = calc.CollateralAssets[i].UnrealisedPNL.Add(decimal.NewFromFloat(pos[j].UnrealizedPNL))
			}
		}
		var collateralByCurrency *order.CollateralByCurrency
		collateralByCurrency, err = f.ScaleCollateral(ctx, &calc.CollateralAssets[i])
		if err != nil {
			if errors.Is(err, errCollateralCurrencyNotFound) {
				log.Error(log.ExchangeSys, err)
				continue
			}
			if errors.Is(err, order.ErrUSDValueRequired) {
				if collateralByCurrency == nil {
					return nil, err
				}
				collateralByCurrency.Error = err
				result.BreakdownByCurrency = append(result.BreakdownByCurrency, *collateralByCurrency)
				continue
			}
			return nil, err
		}

		result.AvailableCollateral = result.AvailableCollateral.Add(collateralByCurrency.CollateralContribution)
		result.UnrealisedPNL = result.UnrealisedPNL.Add(collateralByCurrency.UnrealisedPNL)
		if collateralByCurrency.SkipContribution {
			continue
		}
		result.UsedCollateral = result.UsedCollateral.Add(collateralByCurrency.ScaledUsed)
		result.BreakdownByCurrency = append(result.BreakdownByCurrency, *collateralByCurrency)
	}
	if !result.UnrealisedPNL.IsZero() && result.UsedBreakdown != nil {
		result.AvailableCollateral = decimal.Min(result.AvailableCollateral, result.AvailableCollateral.Add(result.UnrealisedPNL)).Sub(result.UsedBreakdown.LockedAsCollateral)
	}
	return &result, nil
}

func (f *FTX) calculateTotalCollateralOnline(ctx context.Context, calc *order.TotalCollateralCalculator, pos []PositionData) (*order.TotalCollateralResponse, error) {
	if calc == nil {
		return nil, fmt.Errorf("%v CalculateTotalCollateral %w", f.Name, common.ErrNilPointer)
	}
	if len(calc.CollateralAssets) == 0 {
		return nil, fmt.Errorf("%v calculateTotalCollateralOnline %w, no currencies supplied", f.Name, errCollateralCurrencyNotFound)
	}
	if calc.CalculateOffline {
		return nil, fmt.Errorf("%v calculateTotalCollateralOnline %w", f.Name, order.ErrOfflineCalculationSet)
	}

	c, err := f.GetCollateral(ctx, false)
	if err != nil {
		return nil, fmt.Errorf("%s %w", f.Name, err)
	}
	mc, err := f.GetCollateral(ctx, true)
	if err != nil {
		return nil, fmt.Errorf("%s %w", f.Name, err)
	}
	result := order.TotalCollateralResponse{
		CollateralCurrency:                          currency.USD,
		AvailableCollateral:                         c.CollateralAvailable,
		AvailableMaintenanceCollateral:              mc.CollateralAvailable,
		TotalValueOfPositiveSpotBalances:            c.PositiveSpotBalanceTotal,
		CollateralContributedByPositiveSpotBalances: c.CollateralFromPositiveSpotBalances,
	}
	balances, err := f.GetBalances(ctx, true, true)
	if err != nil {
		return nil, fmt.Errorf("%s %w", f.Name, err)
	}

	for x := range calc.CollateralAssets {
		if calc.CollateralAssets[x].CalculateOffline {
			return nil, fmt.Errorf("%v %v %v calculateTotalCollateralOnline %w", f.Name, calc.CollateralAssets[x].Asset, calc.CollateralAssets[x].CollateralCurrency, order.ErrOfflineCalculationSet)
		}
		currencyBreakdown := order.CollateralByCurrency{
			Currency:                    calc.CollateralAssets[x].CollateralCurrency,
			TotalFunds:                  calc.CollateralAssets[x].FreeCollateral.Add(calc.CollateralAssets[x].LockedCollateral),
			AvailableForUseAsCollateral: calc.CollateralAssets[x].FreeCollateral,
			ScaledCurrency:              currency.USD,
		}
		if len(pos) > 0 {
			// use pos unrealisedPNL, not calc.collateralAssets'
			calc.CollateralAssets[x].UnrealisedPNL = decimal.Zero
			for i := range pos {
				if !pos[i].Future.Base.Equal(calc.CollateralAssets[x].CollateralCurrency) {
					continue
				}
				calc.CollateralAssets[x].UnrealisedPNL = calc.CollateralAssets[x].UnrealisedPNL.Add(decimal.NewFromFloat(pos[i].UnrealizedPNL))
			}
		}
		currencyBreakdown.UnrealisedPNL = calc.CollateralAssets[x].UnrealisedPNL

		for y := range c.PositiveBalances {
			if !c.PositiveBalances[y].Coin.Equal(calc.CollateralAssets[x].CollateralCurrency) {
				continue
			}
			currencyBreakdown.Weighting = c.PositiveBalances[y].CollateralWeight
			currencyBreakdown.FairMarketValue = c.PositiveBalances[y].ApproximateFairMarketValue
			currencyBreakdown.CollateralContribution = c.PositiveBalances[y].AvailableIgnoringCollateral.Mul(c.PositiveBalances[y].ApproximateFairMarketValue).Mul(currencyBreakdown.Weighting)
			currencyBreakdown.AdditionalCollateralUsed = c.PositiveBalances[y].CollateralUsed
			currencyBreakdown.FairMarketValue = c.PositiveBalances[y].ApproximateFairMarketValue
			currencyBreakdown.AvailableForUseAsCollateral = c.PositiveBalances[y].AvailableIgnoringCollateral
		}
		for y := range c.NegativeBalances {
			if !c.NegativeBalances[y].Coin.Equal(calc.CollateralAssets[x].CollateralCurrency) {
				continue
			}
			currencyBreakdown.Weighting = c.NegativeBalances[y].CollateralWeight
			currencyBreakdown.FairMarketValue = c.NegativeBalances[y].ApproximateFairMarketValue
			currencyBreakdown.CollateralContribution = c.NegativeBalances[y].AvailableIgnoringCollateral.Mul(c.NegativeBalances[y].ApproximateFairMarketValue).Mul(currencyBreakdown.Weighting)
			currencyBreakdown.AdditionalCollateralUsed = c.NegativeBalances[y].CollateralUsed
			currencyBreakdown.FairMarketValue = c.NegativeBalances[y].ApproximateFairMarketValue
			currencyBreakdown.AvailableForUseAsCollateral = c.NegativeBalances[y].AvailableIgnoringCollateral
		}
		if currencyBreakdown.Weighting.IsZero() {
			currencyBreakdown.SkipContribution = true
		}

		for y := range balances {
			// used to determine how collateral is being used
			if !balances[y].Coin.Equal(calc.CollateralAssets[x].CollateralCurrency) {
				continue
			}
			// staked values are in their own currency, scale it
			lockedS := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedInStakes)
			lockedC := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedAsCollateral)
			lockedF := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedInFeeVoucher)
			lockedN := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedInNFTBids)
			lockedO := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedInSpotOrders)
			lockedFO := decimal.NewFromFloat(balances[y].LockedBreakdown.LockedInSpotMarginFundingOffers)
			locked := decimal.Sum(lockedS, lockedC, lockedF, lockedN, lockedO, lockedFO)
			if !locked.IsZero() || balances[y].SpotBorrow > 0 {
				if result.UsedBreakdown == nil {
					result.UsedBreakdown = &order.UsedCollateralBreakdown{}
				}
				var resetWeightingToZero bool
				if currencyBreakdown.Weighting.IsZero() {
					// this is to ensure we're not hiding any locked values
					// when collateral contribution is zero (eg FTT with collateral disabled)
					resetWeightingToZero = true
					currencyBreakdown.Weighting = decimal.NewFromInt(1)
				}
				var resetFairMarketToZero bool
				if currencyBreakdown.FairMarketValue.IsZero() {
					// this is another edge case for SRM_LOCKED rendering locked data
					currencyBreakdown.SkipContribution = true
					resetFairMarketToZero = true
					currencyBreakdown.FairMarketValue = decimal.NewFromInt(1)
				}
				currencyBreakdown.ScaledUsedBreakdown = &order.UsedCollateralBreakdown{
					LockedInStakes:                  lockedS.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting),
					LockedInNFTBids:                 lockedN.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting),
					LockedInFeeVoucher:              lockedF.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting),
					LockedInSpotMarginFundingOffers: lockedFO.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting),
					LockedInSpotOrders:              lockedO.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting),
					LockedAsCollateral:              lockedC.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting),
				}

				if resetWeightingToZero {
					currencyBreakdown.Weighting = decimal.Zero
				}
				if resetFairMarketToZero {
					currencyBreakdown.FairMarketValue = decimal.Zero
				}

				currencyBreakdown.ScaledUsed = locked.Mul(currencyBreakdown.FairMarketValue).Mul(currencyBreakdown.Weighting)
				if balances[y].SpotBorrow > 0 {
					currencyBreakdown.ScaledUsedBreakdown.UsedInSpotMarginBorrows = currencyBreakdown.CollateralContribution.Abs().Add(currencyBreakdown.AdditionalCollateralUsed)
					currencyBreakdown.ScaledUsed = currencyBreakdown.ScaledUsed.Add(currencyBreakdown.ScaledUsedBreakdown.UsedInSpotMarginBorrows)
				}
				if !currencyBreakdown.SkipContribution {
					result.UsedCollateral = result.UsedCollateral.Add(currencyBreakdown.ScaledUsed)
					result.UsedBreakdown.LockedInStakes = result.UsedBreakdown.LockedInStakes.Add(currencyBreakdown.ScaledUsedBreakdown.LockedInStakes)
					result.UsedBreakdown.LockedAsCollateral = result.UsedBreakdown.LockedAsCollateral.Add(currencyBreakdown.ScaledUsedBreakdown.LockedAsCollateral)
					result.UsedBreakdown.LockedInFeeVoucher = result.UsedBreakdown.LockedInFeeVoucher.Add(currencyBreakdown.ScaledUsedBreakdown.LockedInFeeVoucher)
					result.UsedBreakdown.LockedInNFTBids = result.UsedBreakdown.LockedInNFTBids.Add(currencyBreakdown.ScaledUsedBreakdown.LockedInNFTBids)
					result.UsedBreakdown.LockedInSpotOrders = result.UsedBreakdown.LockedInSpotOrders.Add(currencyBreakdown.ScaledUsedBreakdown.LockedInSpotOrders)
					result.UsedBreakdown.LockedInSpotMarginFundingOffers = result.UsedBreakdown.LockedInSpotMarginFundingOffers.Add(currencyBreakdown.ScaledUsedBreakdown.LockedInSpotMarginFundingOffers)
					result.UsedBreakdown.UsedInSpotMarginBorrows = result.UsedBreakdown.UsedInSpotMarginBorrows.Add(currencyBreakdown.ScaledUsedBreakdown.UsedInSpotMarginBorrows)
				}
			}
		}
		if calc.CollateralAssets[x].CollateralCurrency.Equal(currency.USD) {
			for y := range c.Positions {
				if result.UsedBreakdown == nil {
					result.UsedBreakdown = &order.UsedCollateralBreakdown{}
				}
				result.UsedBreakdown.UsedInPositions = result.UsedBreakdown.UsedInPositions.Add(c.Positions[y].CollateralUsed)
			}
		}
		result.BreakdownByCurrency = append(result.BreakdownByCurrency, currencyBreakdown)
	}

	for y := range c.Positions {
		result.BreakdownOfPositions = append(result.BreakdownOfPositions, order.CollateralByPosition{
			PositionCurrency: c.Positions[y].Future,
			Size:             c.Positions[y].Size,
			OpenOrderSize:    c.Positions[y].OpenOrderSize,
			PositionSize:     c.Positions[y].PositionSize,
			MarkPrice:        c.Positions[y].MarkPrice,
			RequiredMargin:   c.Positions[y].RequiredMargin,
			CollateralUsed:   c.Positions[y].CollateralUsed,
		})
	}

	return &result, nil
}

// GetFuturesPositions returns futures positions based on supplied request
func (f *FTX) GetFuturesPositions(ctx context.Context, request *order.PositionsRequest) ([]order.PositionDetails, error) {
	if request == nil {
		return nil, fmt.Errorf("%w position request", common.ErrNilPointer)
	}
	if !request.Asset.IsFutures() {
		return nil, fmt.Errorf("%w '%s'", order.ErrNotFuturesAsset, request.Asset)
	}
	if err := f.CurrencyPairs.IsAssetEnabled(request.Asset); err != nil {
		return nil, err
	}
	enabledPairs, err := f.CurrencyPairs.GetPairs(request.Asset, true)
	if err != nil {
		return nil, err
	}

	for i := range request.Pairs {
		if !enabledPairs.Contains(request.Pairs[i], false) {
			return nil, fmt.Errorf("%w %v", currency.ErrPairNotFound, request.Pairs[i])
		}
	}

	positionsDetails := make([]order.PositionDetails, len(request.Pairs))
	for x := range request.Pairs {
		fillsOrders := make(map[string]*order.Detail)
		endTime := time.Now()
	allPositions:
		for {
			var fills []FillsData
			fills, err = f.GetFills(ctx, request.Pairs[x], request.Asset, request.StartDate, endTime, "")
			if err != nil {
				return nil, err
			}
			if len(fills) == 0 {
				break allPositions
			}
			sort.Slice(fills, func(i, j int) bool {
				return fills[i].ID < (fills[j].ID)
			})
			for y := range fills {
				if request.StartDate.Equal(fills[y].Time) || fills[y].Time.Before(request.StartDate) {
					// reached end of trades to crawl
					break allPositions
				}
				if fills[y].Time.After(endTime) {
					continue
				}
				var side order.Side
				side, err = order.StringToOrderSide(fills[y].Side)
				if err != nil {
					return nil, err
				}
				oID := strconv.FormatInt(fills[y].ID, 10)
				_, ok := fillsOrders[oID]
				if !ok {
					fillsOrders[oID] = &order.Detail{
						Fee:       fills[y].Fee,
						FeeAsset:  fills[y].FeeCurrency,
						Pair:      request.Pairs[x],
						Price:     fills[y].Price,
						Amount:    fills[y].Size,
						Exchange:  f.Name,
						OrderID:   oID,
						Side:      side,
						Status:    order.Filled,
						AssetType: request.Asset,
						Date:      fills[y].Time,
					}
				}
			}
			if endTime.Equal(fills[len(fills)-1].Time) {
				break allPositions
			}
			endTime = fills[len(fills)-1].Time
		}
		var ods []order.Detail
		for _, v := range fillsOrders {
			ods = append(ods, *v)
		}
		sort.Slice(ods, func(i, j int) bool {
			return ods[i].OrderID < (ods[j].OrderID)
		})
		positionsDetails[x] = order.PositionDetails{
			Exchange: f.Name,
			Asset:    request.Asset,
			Pair:     enabledPairs[x],
			Orders:   ods,
		}
	}
	return positionsDetails, nil
}

// GetCollateralCurrencyForContract returns the collateral currency for an asset and contract pair
func (f *FTX) GetCollateralCurrencyForContract(a asset.Item, _ currency.Pair) (currency.Code, asset.Item, error) {
	return currency.USD, asset.Futures, nil
}

// GetCurrencyForRealisedPNL returns where to put realised PNL
func (f *FTX) GetCurrencyForRealisedPNL(a asset.Item, _ currency.Pair) (currency.Code, asset.Item, error) {
	if !a.IsFutures() {
		return currency.EMPTYCODE, asset.Empty, fmt.Errorf("%v %w", a, order.ErrNotFuturesAsset)
	}
	return currency.USD, asset.Spot, nil
}

// GetMarginRatesHistory gets the margin rate history for the given currency, asset, pair
// Can also include borrow rates, or lending income/borrow payments
func (f *FTX) GetMarginRatesHistory(ctx context.Context, request *margin.RateHistoryRequest) (*margin.RateHistoryResponse, error) {
	if request == nil {
		return nil, fmt.Errorf("%w funding rate request is nil", common.ErrNilPointer)
	}
	if request.Currency.IsEmpty() {
		return nil, fmt.Errorf("%w funding rate request is empty", currency.ErrCurrencyCodeEmpty)
	}
	pairs, err := f.GetEnabledPairs(request.Asset)
	if err != nil {
		return nil, err
	}

	if !pairs.ContainsCurrency(request.Currency) {
		return nil, fmt.Errorf("%w '%v' in enabled pairs", currency.ErrCurrencyNotFound, request.Currency)
	}

	err = common.StartEndTimeCheck(request.StartDate, request.EndDate)
	if err != nil {
		return nil, err
	}

	var (
		one                                              = decimal.NewFromInt(1)
		fiveHundred                                      = decimal.NewFromInt(500)
		twentyFour                                       = decimal.NewFromInt(24)
		threeSixFive                                     = decimal.NewFromInt(365)
		takerFeeRate, averageBorrowSize, averageLendSize decimal.Decimal
		borrowSizeLen, lendSizeLen                       int64
	)

	switch {
	case request.CalculateOffline:
		takerFeeRate = request.TakeFeeRate
	case request.GetBorrowRates:
		var accountInfo AccountInfoData
		accountInfo, err = f.GetAccountInfo(ctx)
		if err != nil {
			return nil, err
		}
		takerFeeRate = decimal.NewFromFloat(accountInfo.TakerFee)
	}
	response := &margin.RateHistoryResponse{
		TakerFeeRate: takerFeeRate,
	}
	if request.CalculateOffline {
		if len(request.Rates) == 0 {
			return nil, fmt.Errorf("%w calculation requires rates", common.ErrCannotCalculateOffline)
		}
		response.Rates = request.Rates
	} else {
		var responseRates []margin.Rate
		endDate := request.EndDate
		for {
			var rates []MarginTransactionHistoryData
			rates, err = f.GetMarginMarketLendingHistory(ctx, request.Currency, request.StartDate, endDate)
			if err != nil {
				return nil, err
			}
			if len(rates) == 0 || rates[len(rates)-1].Time.Equal(endDate) {
				break
			}
			for i := range rates {
				if !rates[i].Coin.Equal(request.Currency) {
					continue
				}
				rate := margin.Rate{
					Time:             rates[i].Time,
					HourlyRate:       decimal.NewFromFloat(rates[i].Rate),
					MarketBorrowSize: decimal.NewFromFloat(rates[i].Size),
				}
				rate.YearlyRate = rate.HourlyRate.Mul(twentyFour.Mul(threeSixFive))
				if request.GetBorrowRates {
					rate.HourlyBorrowRate = rate.HourlyRate.Mul(one.Add(fiveHundred.Mul(takerFeeRate)))
					rate.YearlyBorrowRate = rate.HourlyBorrowRate.Mul(twentyFour.Mul(threeSixFive))
				}
				responseRates = append(responseRates, rate)
			}
			if rates[len(rates)-1].Time.Before(request.StartDate) {
				break
			}
			endDate = rates[len(rates)-1].Time
		}
		if len(responseRates) == 0 {
			return nil, fmt.Errorf("%w no rates returned between %v-%v", common.ErrNoResponse, request.StartDate, request.EndDate)
		}
		sort.Slice(responseRates, func(i, j int) bool {
			return responseRates[i].Time.Before(responseRates[j].Time)
		})
		response.Rates = responseRates
	}

	if request.GetPredictedRate {
		if request.CalculateOffline {
			return nil, fmt.Errorf("%w predicted rate is online only", common.ErrCannotCalculateOffline)
		}
		var borrowRates []MarginFundingData
		borrowRates, err = f.GetMarginLendingRates(ctx)
		if err != nil {
			return nil, err
		}
		for i := range borrowRates {
			if !borrowRates[i].Coin.Equal(request.Currency) {
				continue
			}
			response.PredictedRate = margin.Rate{
				Time:       response.Rates[len(response.Rates)-1].Time.Add(time.Hour),
				HourlyRate: decimal.NewFromFloat(borrowRates[i].Estimate),
			}
			response.PredictedRate.YearlyRate = response.PredictedRate.HourlyRate.Mul(twentyFour.Mul(threeSixFive))

			if request.GetBorrowRates {
				response.PredictedRate.HourlyBorrowRate = response.PredictedRate.HourlyRate.Mul(one.Add(fiveHundred.Mul(takerFeeRate)))
				response.PredictedRate.YearlyBorrowRate = response.PredictedRate.HourlyBorrowRate.Mul(twentyFour.Mul(threeSixFive))
			}
		}
	}
	if request.GetLendingPayments {
		if request.CalculateOffline {
			if request.TakeFeeRate.IsZero() {
				return nil, fmt.Errorf("%w taker fee unset", common.ErrCannotCalculateOffline)
			}
			for i := range request.Rates {
				response.Rates[i].LendingPayment.Payment = response.Rates[i].HourlyRate.Mul(response.Rates[i].LendingPayment.Size)
				response.SumLendingPayments = response.SumLendingPayments.Add(response.Rates[i].LendingPayment.Payment)
				averageLendSize = averageLendSize.Add(response.Rates[i].LendingPayment.Size)
				lendSizeLen++
			}
		} else {
			endDate := request.EndDate
			for {
				var payments []MarginTransactionHistoryData
				payments, err = f.GetMarginLendingHistory(ctx, request.Currency, request.StartDate, endDate)
				if err != nil {
					return nil, err
				}
				if len(payments) == 0 || payments[len(payments)-1].Time.Equal(endDate) {
					break
				}
				for i := range payments {
					if !payments[i].Coin.Equal(request.Currency) {
						continue
					}
					for j := range response.Rates {
						if !response.Rates[j].Time.Equal(payments[i].Time) {
							continue
						}
						response.Rates[j].LendingPayment.Payment = decimal.NewFromFloat(payments[i].Proceeds)
						response.Rates[j].LendingPayment.Size = decimal.NewFromFloat(payments[i].Size)
						response.SumLendingPayments = response.SumLendingPayments.Add(response.Rates[j].LendingPayment.Payment)
						averageLendSize = averageLendSize.Add(response.Rates[j].LendingPayment.Size)
						lendSizeLen++
						break
					}
				}
				if payments[len(payments)-1].Time.Before(request.StartDate) {
					break
				}
				endDate = payments[len(payments)-1].Time
			}
		}
	}
	if request.GetBorrowCosts {
		if request.CalculateOffline {
			if request.TakeFeeRate.IsZero() {
				return nil, fmt.Errorf("%w taker fee unset", common.ErrCannotCalculateOffline)
			}
			for i := range request.Rates {
				response.Rates[i].HourlyBorrowRate = response.Rates[i].HourlyRate.Mul(one.Add(fiveHundred.Mul(takerFeeRate)))
				response.Rates[i].YearlyBorrowRate = response.Rates[i].HourlyBorrowRate.Mul(one.Add(fiveHundred.Mul(takerFeeRate)))
				response.Rates[i].BorrowCost.Cost = response.Rates[i].HourlyBorrowRate.Mul(response.Rates[i].BorrowCost.Size)
				response.SumBorrowCosts = response.SumBorrowCosts.Add(response.Rates[i].BorrowCost.Cost)
				averageBorrowSize = averageBorrowSize.Add(response.Rates[i].BorrowCost.Size)
				borrowSizeLen++
			}
		} else {
			endDate := request.EndDate
			for {
				var costs []MarginTransactionHistoryData
				costs, err = f.GetMarginBorrowHistory(ctx, request.StartDate, endDate)
				if err != nil {
					return nil, err
				}
				if len(costs) == 0 || costs[len(costs)-1].Time.Equal(endDate) {
					break
				}
				for i := range costs {
					if !costs[i].Coin.Equal(request.Currency) {
						continue
					}
					for j := range response.Rates {
						if !response.Rates[j].Time.Equal(costs[i].Time) {
							continue
						}
						response.Rates[j].BorrowCost.Cost = decimal.NewFromFloat(costs[i].Cost)
						response.Rates[j].BorrowCost.Size = decimal.NewFromFloat(costs[i].Size)
						response.SumBorrowCosts = response.SumBorrowCosts.Add(response.Rates[j].BorrowCost.Cost)
						averageBorrowSize = averageBorrowSize.Add(response.Rates[j].BorrowCost.Size)
						borrowSizeLen++
						break
					}
				}
				if costs[len(costs)-1].Time.Before(request.StartDate) {
					break
				}
				endDate = costs[len(costs)-1].Time
			}
		}
	}

	if borrowSizeLen > 0 {
		response.AverageBorrowSize = averageBorrowSize.Div(decimal.NewFromInt(borrowSizeLen))
	}
	if lendSizeLen > 0 {
		response.AverageLendingSize = averageLendSize.Div(decimal.NewFromInt(lendSizeLen))
	}

	return response, nil
}

// GetPositionSummary returns an overview of a future position
func (f *FTX) GetPositionSummary(ctx context.Context, request *order.PositionSummaryRequest) (*order.PositionSummary, error) {
	if request == nil {
		return nil, fmt.Errorf("%w PositionSummaryRequest", common.ErrNilPointer)
	}
	if !request.Asset.IsFutures() {
		return nil, fmt.Errorf("%w '%s' is not a futures asset", asset.ErrNotSupported, request.Asset)
	}
	if err := f.CurrencyPairs.IsAssetEnabled(request.Asset); err != nil {
		return nil, err
	}

	if request.CalculateOffline {
		one := decimal.NewFromInt(1)
		positionSize := request.CurrentSize.Mul(request.CurrentPrice)
		var marginFraction decimal.Decimal
		if positionSize.IsPositive() && request.TotalCollateral.IsPositive() {
			marginFraction = request.TotalCollateral.Div(positionSize).Mul(decimal.NewFromFloat(100))
		}
		breakEvenPrice := request.OpeningPrice
		if !request.OpeningSize.Equal(request.CurrentSize) {
			breakEvenPrice = request.OpeningPrice.Mul(request.OpeningSize).Sub(request.CurrentSize.Mul(request.CurrentPrice)).Div(request.OpeningSize.Sub(request.CurrentSize))
		}
		var maintenanceMarginRequirement, positionMaintenanceMarginFraction decimal.Decimal
		currSize := request.CurrentSize
		openSize := request.OpeningSize
		if request.Leverage.LessThanOrEqual(decimal.NewFromFloat(20)) {
			positionMaintenanceMarginFraction = decimal.NewFromFloat(0.03)
		} else {
			// leverage can never be above 20, but will remain in event of change in policy
			positionMaintenanceMarginFraction = decimal.NewFromFloat(0.006)
		}
		// baseIMF is always 1/20 as 20 is the max leverage
		baseIMF := one.Div(decimal.NewFromInt(20))
		maintenanceMarginRequirement = decimal.Max(positionMaintenanceMarginFraction, decimal.NewFromFloat(0.6).Mul(baseIMF))

		if request.Direction.IsShort() {
			currSize = currSize.Neg()
			openSize = openSize.Neg()
		}
		imf := one.Div(request.Leverage)
		// estimated liquidation price is not included in offline summary
		// the formula does not match the API output - despite the example matching
		// see https://help.ftx.com/hc/en-us/articles/360027668712-Liquidations vs
		// https://docs.ftx.com/#get-account-information
		return &order.PositionSummary{
			MaintenanceMarginRequirement: maintenanceMarginRequirement,
			InitialMarginRequirement:     imf,
			CollateralUsed:               request.CollateralUsed,
			MarkPrice:                    request.CurrentPrice,
			CurrentSize:                  request.CurrentSize.Abs(),
			BreakEvenPrice:               breakEvenPrice,
			AverageOpenPrice:             request.OpeningPrice,
			RecentPNL:                    request.CurrentPrice.Mul(currSize).Sub(request.OpeningPrice.Mul(openSize)),
			MarginFraction:               marginFraction,
			FreeCollateral:               request.FreeCollateral,
			TotalCollateral:              request.TotalCollateral,
		}, nil
	}
	positions, err := f.GetPositions(ctx, true)
	if err != nil {
		return nil, err
	}
	acc, err := f.GetAccountInfo(ctx)
	if err != nil {
		return nil, err
	}
	for i := range positions {
		if !positions[i].Future.Equal(request.Pair) {
			continue
		}
		return &order.PositionSummary{
			MaintenanceMarginRequirement: decimal.NewFromFloat(positions[i].MaintenanceMarginRequirement),
			InitialMarginRequirement:     decimal.NewFromFloat(positions[i].InitialMarginRequirement),
			EstimatedLiquidationPrice:    decimal.NewFromFloat(positions[i].EstimatedLiquidationPrice),
			CollateralUsed:               decimal.NewFromFloat(positions[i].CollateralUsed),
			MarkPrice:                    decimal.NewFromFloat(positions[i].EntryPrice),
			CurrentSize:                  decimal.NewFromFloat(positions[i].Size),
			BreakEvenPrice:               decimal.NewFromFloat(positions[i].RecentBreakEvenPrice),
			AverageOpenPrice:             decimal.NewFromFloat(positions[i].RecentAverageOpenPrice),
			RecentPNL:                    decimal.NewFromFloat(positions[i].RecentPNL),
			MarginFraction:               decimal.NewFromFloat(acc.MarginFraction * 100),
			FreeCollateral:               decimal.NewFromFloat(acc.FreeCollateral),
			TotalCollateral:              decimal.NewFromFloat(acc.Collateral),
		}, nil
	}
	return nil, fmt.Errorf("unable to calculate position summary %w for %v %v", order.ErrPositionNotFound, request.Asset, request.Pair)
}

// GetFundingRates returns stats about funding rates for pairs
func (f *FTX) GetFundingRates(ctx context.Context, request *order.FundingRatesRequest) ([]order.FundingRates, error) {
	if request == nil {
		return nil, fmt.Errorf("%w FundingRatesRequest", common.ErrNilPointer)
	}
	if len(request.Pairs) == 0 {
		return nil, currency.ErrCurrencyPairsEmpty
	}
	var limit int64 = 1000
	err := common.StartEndTimeCheck(request.StartDate, request.EndDate)
	if err != nil {
		return nil, err
	}
	pairFmt, err := f.GetPairFormat(request.Asset, true)
	if err != nil {
		return nil, err
	}
	request.Pairs = request.Pairs.Format(pairFmt)
	response := make([]order.FundingRates, 0, len(request.Pairs))
	for x := range request.Pairs {
		var isPerp bool
		isPerp, err = f.IsPerpetualFutureCurrency(request.Asset, request.Pairs[x])
		if err != nil {
			return nil, err
		}
		if !isPerp {
			return nil, fmt.Errorf("%w '%v' '%v'", order.ErrNotPerpetualFuture, request.Asset, request.Pairs[x])
		}
		var (
			rates          []FundingRatesData
			fundingDetails []FundingPaymentsData
			stats          FutureStatsData
		)
		pairResponse := order.FundingRates{
			Exchange:  f.Name,
			Asset:     request.Asset,
			Pair:      request.Pairs[x],
			StartDate: request.StartDate,
			EndDate:   request.EndDate,
		}
		endTime := request.EndDate
	allRates:
		for {
			rates, err = f.FundingRates(ctx, request.StartDate, endTime, request.Pairs[x], limit)
			if err != nil {
				return nil, err
			}
			if len(rates) == 0 {
				break allRates
			}
		responseRates:
			for y := range rates {
				if rates[y].Time.Before(request.StartDate) {
					break allRates
				}
				if rates[y].Time.After(endTime) {
					continue
				}
				for z := range pairResponse.FundingRates {
					if rates[y].Time.Equal(pairResponse.FundingRates[z].Time) {
						continue responseRates
					}
				}
				pairResponse.FundingRates = append(pairResponse.FundingRates, order.FundingRate{
					Rate: decimal.NewFromFloat(rates[y].Rate),
					Time: rates[y].Time,
				})
			}
			if endTime.Equal(rates[len(rates)-1].Time) || int64(len(rates)) < limit {
				break allRates
			}
			endTime = rates[len(rates)-1].Time
		}
		if len(pairResponse.FundingRates) == 0 {
			continue
		}
		if request.IncludePayments {
			fundingDetails, err = f.getFundingPayments(ctx, request.StartDate, request.EndDate, request.Pairs[x], limit)
			if err != nil {
				return nil, err
			}
			for y := range fundingDetails {
				for z := range pairResponse.FundingRates {
					if !fundingDetails[y].Time.Equal(pairResponse.FundingRates[z].Time) {
						continue
					}
					pairResponse.FundingRates[z].Payment = decimal.NewFromFloat(fundingDetails[y].Payment)
					pairResponse.PaymentSum = pairResponse.PaymentSum.Add(decimal.NewFromFloat(fundingDetails[y].Payment))
					break
				}
			}
		}
		if request.IncludePredictedRate {
			stats, err = f.GetFutureStats(ctx, request.Pairs[x])
			if err != nil {
				return nil, err
			}
			upcoming := order.FundingRate{
				Rate: decimal.NewFromFloat(stats.NextFundingRate),
				Time: stats.NextFundingTime,
			}
			pairResponse.PredictedUpcomingRate = upcoming
		}
		sort.Slice(pairResponse.FundingRates, func(i, j int) bool {
			return pairResponse.FundingRates[i].Time.Before(pairResponse.FundingRates[j].Time)
		})
		pairResponse.LatestRate = pairResponse.FundingRates[len(pairResponse.FundingRates)-1]
		response = append(response, pairResponse)
	}
	return response, nil
}

func (f *FTX) getFundingPayments(ctx context.Context, startDate, endDate time.Time, future currency.Pair, limit int64) ([]FundingPaymentsData, error) {
	requestEndTime := endDate
	var payments []FundingPaymentsData
allRates:
	for {
		fundingDetails, err := f.FundingPayments(ctx, startDate, requestEndTime, future, limit)
		if err != nil {
			return nil, err
		}
		if len(fundingDetails) == 0 {
			break allRates
		}
	responseRates:
		for x := range fundingDetails {
			if fundingDetails[x].Time.Before(startDate) {
				break allRates
			}
			if fundingDetails[x].Time.After(requestEndTime) {
				continue
			}
			for y := range payments {
				if fundingDetails[x].Time.Equal(payments[y].Time) {
					continue responseRates
				}
			}
			payments = append(payments, fundingDetails[x])
		}
		if requestEndTime.Equal(fundingDetails[len(fundingDetails)-1].Time) || int64(len(fundingDetails)) < limit {
			break allRates
		}
		requestEndTime = fundingDetails[len(fundingDetails)-1].Time
	}
	return payments, nil
}

// IsPerpetualFutureCurrency returns whether a currency is a perpetual future
func (f *FTX) IsPerpetualFutureCurrency(a asset.Item, cp currency.Pair) (bool, error) {
	if err := f.CurrencyPairs.IsAssetEnabled(a); err != nil {
		return false, err
	}
	pairs, err := f.GetEnabledPairs(a)
	if err != nil {
		return false, err
	}
	if !pairs.Contains(cp, false) {
		return false, fmt.Errorf("%w '%v'", currency.ErrPairNotFound, cp)
	}
	return cp.Quote.Equal(currency.PERP) && a.IsFutures(), nil
}