package bitget

import (
	"context"
	"encoding/json"
	"io"
	"math"
	"net/http"
	"os"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"

	v2 "github.com/c9s/bbgo/pkg/exchange/bitget/bitgetapi/v2"
	"github.com/c9s/bbgo/pkg/fixedpoint"
	"github.com/c9s/bbgo/pkg/testing/httptesting"
	"github.com/c9s/bbgo/pkg/types"
)

func TestExchange_QueryMarkets(t *testing.T) {
	ex := New("key", "secret", "passphrase")

	t.Run("succeeds", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/get_symbols_request.json")
		assert.NoError(t, err)

		transport.GET("/api/v2/spot/public/symbols", func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponseString(http.StatusOK, string(f)), nil
		})

		mkts, err := ex.QueryMarkets(context.Background())
		assert.NoError(t, err)

		expMkts := types.MarketMap{
			"ETHUSDT": types.Market{
				Exchange:        types.ExchangeBitget,
				Symbol:          "ETHUSDT",
				LocalSymbol:     "ETHUSDT",
				PricePrecision:  2,
				VolumePrecision: 4,
				QuoteCurrency:   "USDT",
				BaseCurrency:    "ETH",
				MinNotional:     fixedpoint.NewFromInt(5),
				MinAmount:       fixedpoint.NewFromInt(5),
				MinQuantity:     fixedpoint.NewFromInt(0),
				MaxQuantity:     fixedpoint.NewFromInt(10000000000),
				StepSize:        fixedpoint.NewFromFloat(1.0 / math.Pow10(4)),
				TickSize:        fixedpoint.NewFromFloat(1.0 / math.Pow10(2)),
				MinPrice:        fixedpoint.Zero,
				MaxPrice:        fixedpoint.Zero,
			},
			"BTCUSDT": types.Market{
				Exchange:        types.ExchangeBitget,
				Symbol:          "BTCUSDT",
				LocalSymbol:     "BTCUSDT",
				PricePrecision:  2,
				VolumePrecision: 6,
				QuoteCurrency:   "USDT",
				BaseCurrency:    "BTC",
				MinNotional:     fixedpoint.NewFromInt(5),
				MinAmount:       fixedpoint.NewFromInt(5),
				MinQuantity:     fixedpoint.NewFromInt(0),
				MaxQuantity:     fixedpoint.NewFromInt(10000000000),
				StepSize:        fixedpoint.NewFromFloat(1.0 / math.Pow10(6)),
				TickSize:        fixedpoint.NewFromFloat(1.0 / math.Pow10(2)),
				MinPrice:        fixedpoint.Zero,
				MaxPrice:        fixedpoint.Zero,
			},
		}
		assert.Equal(t, expMkts, mkts)
	})

	t.Run("error", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/request_error.json")
		assert.NoError(t, err)

		transport.GET("/api/v2/spot/public/symbols", func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponseString(http.StatusBadRequest, string(f)), nil
		})

		_, err = ex.QueryMarkets(context.Background())
		assert.ErrorContains(t, err, "Invalid IP")
	})
}

func TestExchange_QueryTicker(t *testing.T) {
	var (
		assert = assert.New(t)
		ex     = New("key", "secret", "passphrase")
		url    = "/api/v2/spot/market/tickers"
	)

	t.Run("succeeds", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/get_ticker_request.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponseString(http.StatusOK, string(f)), nil
		})

		tickers, err := ex.QueryTicker(context.Background(), "BTCUSDT")
		assert.NoError(err)
		expTicker := &types.Ticker{
			Time:   types.NewMillisecondTimestampFromInt(1709626631127).Time(),
			Volume: fixedpoint.MustNewFromString("29439.351448"),
			Last:   fixedpoint.MustNewFromString("66554.03"),
			Open:   fixedpoint.MustNewFromString("64654.54"),
			High:   fixedpoint.MustNewFromString("68686.93"),
			Low:    fixedpoint.MustNewFromString("64583.42"),
			Buy:    fixedpoint.MustNewFromString("66554"),
			Sell:   fixedpoint.MustNewFromString("66554.07"),
		}
		assert.Equal(expTicker, tickers)
	})

	t.Run("unexpected length", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/get_tickers_request.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponseString(http.StatusOK, string(f)), nil
		})

		_, err = ex.QueryTicker(context.Background(), "BTCUSDT")
		assert.ErrorContains(err, "unexpected length of query")
	})

	t.Run("error", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/request_error.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponseString(http.StatusBadRequest, string(f)), nil
		})

		_, err = ex.QueryTicker(context.Background(), "BTCUSDT")
		assert.ErrorContains(err, "Invalid IP")
	})
}

func TestExchange_QueryTickers(t *testing.T) {
	var (
		assert       = assert.New(t)
		ex           = New("key", "secret", "passphrase")
		url          = "/api/v2/spot/market/tickers"
		expBtcSymbol = "BTCUSDT"
		expBtcTicker = types.Ticker{
			Time:   types.NewMillisecondTimestampFromInt(1709626631127).Time(),
			Volume: fixedpoint.MustNewFromString("29439.351448"),
			Last:   fixedpoint.MustNewFromString("66554.03"),
			Open:   fixedpoint.MustNewFromString("64654.54"),
			High:   fixedpoint.MustNewFromString("68686.93"),
			Low:    fixedpoint.MustNewFromString("64583.42"),
			Buy:    fixedpoint.MustNewFromString("66554"),
			Sell:   fixedpoint.MustNewFromString("66554.07"),
		}
	)

	t.Run("succeeds", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/get_tickers_request.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponseString(http.StatusOK, string(f)), nil
		})

		tickers, err := ex.QueryTickers(context.Background())
		assert.NoError(err)
		expTickers := map[string]types.Ticker{
			expBtcSymbol: expBtcTicker,
			"ETHUSDT": {
				Time:   types.NewMillisecondTimestampFromInt(1709626631726).Time(),
				Volume: fixedpoint.MustNewFromString("243220.866"),
				Last:   fixedpoint.MustNewFromString("3686.95"),
				Open:   fixedpoint.MustNewFromString("3506.6"),
				High:   fixedpoint.MustNewFromString("3740"),
				Low:    fixedpoint.MustNewFromString("3461.17"),
				Buy:    fixedpoint.MustNewFromString("3686.94"),
				Sell:   fixedpoint.MustNewFromString("3686.98"),
			},
		}
		assert.Equal(expTickers, tickers)
	})

	t.Run("succeeds for query one markets", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/get_ticker_request.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			assert.Contains(req.URL.Query(), "symbol")
			assert.Equal(req.URL.Query()["symbol"], []string{expBtcSymbol})
			return httptesting.BuildResponseString(http.StatusOK, string(f)), nil
		})

		tickers, err := ex.QueryTickers(context.Background(), expBtcSymbol)
		assert.NoError(err)
		expTickers := map[string]types.Ticker{
			expBtcSymbol: expBtcTicker,
		}
		assert.Equal(expTickers, tickers)
	})

	t.Run("error", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/request_error.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponseString(http.StatusBadRequest, string(f)), nil
		})

		_, err = ex.QueryTicker(context.Background(), expBtcSymbol)
		assert.ErrorContains(err, "Invalid IP")
	})
}

func TestExchange_QueryKLines(t *testing.T) {
	var (
		assert       = assert.New(t)
		ex           = New("key", "secret", "passphrase")
		url          = "/api/v2/spot/market/candles"
		expBtcSymbol = "BTCUSDT"
		interval     = types.Interval4h
		expBtcKlines = []types.KLine{
			{
				Exchange:    types.ExchangeBitget,
				Symbol:      expBtcSymbol,
				StartTime:   types.Time(types.NewMillisecondTimestampFromInt(1709352000000).Time()),
				EndTime:     types.Time(types.NewMillisecondTimestampFromInt(1709352000000).Time().Add(interval.Duration() - time.Millisecond)),
				Interval:    interval,
				Open:        fixedpoint.MustNewFromString("62308.42"),
				Close:       fixedpoint.MustNewFromString("62014.17"),
				High:        fixedpoint.MustNewFromString("62308.43"),
				Low:         fixedpoint.MustNewFromString("61760"),
				Volume:      fixedpoint.MustNewFromString("987.377637"),
				QuoteVolume: fixedpoint.MustNewFromString("61283110.57046518"),
				Closed:      false,
			},
			{
				Exchange:    types.ExchangeBitget,
				Symbol:      expBtcSymbol,
				StartTime:   types.Time(types.NewMillisecondTimestampFromInt(1709366400000).Time()),
				EndTime:     types.Time(types.NewMillisecondTimestampFromInt(1709366400000).Time().Add(interval.Duration() - time.Millisecond)),
				Interval:    interval,
				Open:        fixedpoint.MustNewFromString("62014.17"),
				Close:       fixedpoint.MustNewFromString("61825.64"),
				High:        fixedpoint.MustNewFromString("62122.8"),
				Low:         fixedpoint.MustNewFromString("61648.26"),
				Volume:      fixedpoint.MustNewFromString("1271.183413"),
				QuoteVolume: fixedpoint.MustNewFromString("78680550.55539777"),
				Closed:      false,
			},
		}
	)

	t.Run("succeeds without time range", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/get_k_line_request.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			query := req.URL.Query()
			assert.Len(query, 3)
			assert.Contains(query, "symbol")
			assert.Contains(query, "granularity")
			assert.Contains(query, "limit")
			assert.Equal(query["symbol"], []string{expBtcSymbol})
			assert.Equal(query["granularity"], []string{interval.String()})
			assert.Equal(query["limit"], []string{strconv.Itoa(defaultKLineLimit)})
			return httptesting.BuildResponseString(http.StatusOK, string(f)), nil
		})

		klines, err := ex.QueryKLines(context.Background(), expBtcSymbol, interval, types.KLineQueryOptions{})
		assert.NoError(err)
		assert.Equal(expBtcKlines, klines)
	})

	t.Run("succeeds with time range", func(t *testing.T) {
		var (
			transport   = &httptesting.MockTransport{}
			limit       = 50
			startTime   = time.Now()
			endTime     = startTime.Add(8 * time.Hour)
			startTimeMs = strconv.FormatInt(startTime.UnixNano()/int64(time.Millisecond), 10)
			endTimeMs   = strconv.FormatInt(endTime.UnixNano()/int64(time.Millisecond), 10)
		)

		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/get_k_line_request.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			query := req.URL.Query()
			assert.Len(query, 5)
			assert.Contains(query, "symbol")
			assert.Contains(query, "granularity")
			assert.Contains(query, "limit")
			assert.Contains(query, "startTime")
			assert.Contains(query, "endTime")
			assert.Equal(query["symbol"], []string{expBtcSymbol})
			assert.Equal(query["granularity"], []string{interval.String()})
			assert.Equal(query["limit"], []string{strconv.Itoa(limit)})
			assert.Equal(query["startTime"], []string{startTimeMs})
			assert.Equal(query["endTime"], []string{endTimeMs})

			return httptesting.BuildResponseString(http.StatusOK, string(f)), nil
		})

		klines, err := ex.QueryKLines(context.Background(), expBtcSymbol, interval, types.KLineQueryOptions{
			Limit:     limit,
			StartTime: &startTime,
			EndTime:   &endTime,
		})
		assert.NoError(err)
		assert.Equal(expBtcKlines, klines)
	})

	t.Run("error", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/request_error.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponseString(http.StatusBadRequest, string(f)), nil
		})

		_, err = ex.QueryKLines(context.Background(), expBtcSymbol, interval, types.KLineQueryOptions{})
		assert.ErrorContains(err, "Invalid IP")
	})

	t.Run("reach max duration", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponse(http.StatusBadRequest, nil), nil
		})

		before31Days := time.Now().Add(-31 * 24 * time.Hour)
		_, err := ex.QueryKLines(context.Background(), expBtcSymbol, types.Interval1m, types.KLineQueryOptions{
			EndTime: &before31Days,
		})
		assert.ErrorContains(err, "are greater than max duration")
	})

	t.Run("end time before start time", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponse(http.StatusBadRequest, nil), nil
		})

		startTime := time.Now()
		endTime := startTime.Add(-time.Hour)
		_, err := ex.QueryKLines(context.Background(), expBtcSymbol, types.Interval1m, types.KLineQueryOptions{
			StartTime: &startTime,
			EndTime:   &endTime,
		})
		assert.ErrorContains(err, "before start time")
	})

	t.Run("unexpected duraiton", func(t *testing.T) {
		_, err := ex.QueryKLines(context.Background(), expBtcSymbol, "87h", types.KLineQueryOptions{})
		assert.ErrorContains(err, "not supported")
	})
}

func TestExchange_QueryAccount(t *testing.T) {
	var (
		assert     = assert.New(t)
		ex         = New("key", "secret", "passphrase")
		url        = "/api/v2/spot/account/assets"
		expAccount = &types.Account{
			AccountType:        "spot",
			FuturesInfo:        nil,
			MarginInfo:         nil,
			IsolatedMarginInfo: nil,
			MarginLevel:        fixedpoint.Zero,
			MarginTolerance:    fixedpoint.Zero,
			BorrowEnabled:      false,
			TransferEnabled:    false,
			MarginRatio:        fixedpoint.Zero,
			LiquidationPrice:   fixedpoint.Zero,
			LiquidationRate:    fixedpoint.Zero,
			MakerFeeRate:       fixedpoint.Zero,
			TakerFeeRate:       fixedpoint.Zero,
			TotalAccountValue:  fixedpoint.Zero,
			CanDeposit:         false,
			CanTrade:           false,
			CanWithdraw:        false,
		}
		balances = types.BalanceMap{
			"BTC": {
				Currency:          "BTC",
				Available:         fixedpoint.MustNewFromString("0.00000690"),
				Locked:            fixedpoint.Zero,
				Borrowed:          fixedpoint.Zero,
				Interest:          fixedpoint.Zero,
				NetAsset:          fixedpoint.Zero,
				MaxWithdrawAmount: fixedpoint.Zero,
			},
			"USDT": {
				Currency:          "USDT",
				Available:         fixedpoint.MustNewFromString("0.68360342"),
				Locked:            fixedpoint.MustNewFromString("9.08096000"),
				Borrowed:          fixedpoint.Zero,
				Interest:          fixedpoint.Zero,
				NetAsset:          fixedpoint.Zero,
				MaxWithdrawAmount: fixedpoint.Zero,
			},
		}
	)
	expAccount.UpdateBalances(balances)

	t.Run("succeeds", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/get_account_assets_request.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			query := req.URL.Query()
			assert.Len(query, 1)
			assert.Contains(query, "limit")
			assert.Equal(query["limit"], []string{string(v2.AssetTypeHoldOnly)})
			return httptesting.BuildResponseString(http.StatusOK, string(f)), nil
		})

		acct, err := ex.QueryAccount(context.Background())
		assert.NoError(err)
		assert.Equal(expAccount, acct)
	})

	t.Run("error", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/request_error.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponseString(http.StatusBadRequest, string(f)), nil
		})

		_, err = ex.QueryAccount(context.Background())
		assert.ErrorContains(err, "Invalid IP")
	})
}

func TestExchange_QueryAccountBalances(t *testing.T) {
	var (
		assert         = assert.New(t)
		ex             = New("key", "secret", "passphrase")
		url            = "/api/v2/spot/account/assets"
		expBalancesMap = types.BalanceMap{
			"BTC": {
				Currency:          "BTC",
				Available:         fixedpoint.MustNewFromString("0.00000690"),
				Locked:            fixedpoint.Zero,
				Borrowed:          fixedpoint.Zero,
				Interest:          fixedpoint.Zero,
				NetAsset:          fixedpoint.Zero,
				MaxWithdrawAmount: fixedpoint.Zero,
			},
			"USDT": {
				Currency:          "USDT",
				Available:         fixedpoint.MustNewFromString("0.68360342"),
				Locked:            fixedpoint.MustNewFromString("9.08096000"),
				Borrowed:          fixedpoint.Zero,
				Interest:          fixedpoint.Zero,
				NetAsset:          fixedpoint.Zero,
				MaxWithdrawAmount: fixedpoint.Zero,
			},
		}
	)

	t.Run("succeeds", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/get_account_assets_request.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			query := req.URL.Query()
			assert.Len(query, 1)
			assert.Contains(query, "limit")
			assert.Equal(query["limit"], []string{string(v2.AssetTypeHoldOnly)})
			return httptesting.BuildResponseString(http.StatusOK, string(f)), nil
		})

		acct, err := ex.QueryAccountBalances(context.Background())
		assert.NoError(err)
		assert.Equal(expBalancesMap, acct)
	})

	t.Run("error", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		f, err := os.ReadFile("bitgetapi/v2/testdata/request_error.json")
		assert.NoError(err)

		transport.GET(url, func(req *http.Request) (*http.Response, error) {
			return httptesting.BuildResponseString(http.StatusBadRequest, string(f)), nil
		})

		_, err = ex.QueryAccountBalances(context.Background())
		assert.ErrorContains(err, "Invalid IP")
	})
}

func TestExchange_SubmitOrder(t *testing.T) {
	var (
		assert        = assert.New(t)
		ex            = New("key", "secret", "passphrase")
		placeOrderUrl = "/api/v2/spot/trade/place-order"
		openOrderUrl  = "/api/v2/spot/trade/unfilled-orders"
		clientOrderId = "684a79df-f931-474f-a9a5-f1deab1cd770"
		expBtcSymbol  = "BTCUSDT"
		expOrder      = &types.Order{
			SubmitOrder: types.SubmitOrder{
				ClientOrderID: clientOrderId,
				Symbol:        expBtcSymbol,
				Side:          types.SideTypeBuy,
				Type:          types.OrderTypeLimit,
				Quantity:      fixedpoint.MustNewFromString("0.00009"),
				Price:         fixedpoint.MustNewFromString("66000"),
				TimeInForce:   types.TimeInForceGTC,
			},
			Exchange:         types.ExchangeBitget,
			OrderID:          1148903850645331968,
			UUID:             "1148903850645331968",
			Status:           types.OrderStatusNew,
			ExecutedQuantity: fixedpoint.Zero,
			IsWorking:        true,
			CreationTime:     types.Time(types.NewMillisecondTimestampFromInt(1709645944272).Time()),
			UpdateTime:       types.Time(types.NewMillisecondTimestampFromInt(1709645944272).Time()),
		}
		reqLimitOrder = types.SubmitOrder{
			ClientOrderID: clientOrderId,
			Symbol:        expBtcSymbol,
			Side:          types.SideTypeBuy,
			Type:          types.OrderTypeLimit,
			Quantity:      fixedpoint.MustNewFromString("0.00009"),
			Price:         fixedpoint.MustNewFromString("66000"),
			Market: types.Market{
				Symbol:          expBtcSymbol,
				LocalSymbol:     expBtcSymbol,
				PricePrecision:  fixedpoint.MustNewFromString("2").Int(),
				VolumePrecision: fixedpoint.MustNewFromString("6").Int(),
				StepSize:        fixedpoint.NewFromFloat(1.0 / math.Pow10(6)),
				TickSize:        fixedpoint.NewFromFloat(1.0 / math.Pow10(2)),
			},
			TimeInForce: types.TimeInForceGTC,
		}
	)

	type NewOrder struct {
		ClientOid string `json:"clientOid"`
		Force     string `json:"force"`
		OrderType string `json:"orderType"`
		Price     string `json:"price"`
		Side      string `json:"side"`
		Size      string `json:"size"`
		Symbol    string `json:"symbol"`
	}

	t.Run("Limit order", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		placeOrderFile, err := os.ReadFile("bitgetapi/v2/testdata/place_order_request.json")
		assert.NoError(err)

		transport.POST(placeOrderUrl, func(req *http.Request) (*http.Response, error) {
			raw, err := io.ReadAll(req.Body)
			assert.NoError(err)

			reqq := &NewOrder{}
			err = json.Unmarshal(raw, &reqq)
			assert.NoError(err)
			assert.Equal(&NewOrder{
				ClientOid: expOrder.ClientOrderID,
				Force:     string(v2.OrderForceGTC),
				OrderType: string(v2.OrderTypeLimit),
				Price:     "66000.00",
				Side:      string(v2.SideTypeBuy),
				Size:      "0.000090",
				Symbol:    expBtcSymbol,
			}, reqq)

			return httptesting.BuildResponseString(http.StatusOK, string(placeOrderFile)), nil
		})

		unfilledFile, err := os.ReadFile("bitgetapi/v2/testdata/get_unfilled_orders_request_limit_order.json")
		assert.NoError(err)

		transport.GET(openOrderUrl, func(req *http.Request) (*http.Response, error) {
			query := req.URL.Query()
			assert.Len(query, 1)
			assert.Contains(query, "orderId")
			assert.Equal(query["orderId"], []string{strconv.FormatUint(expOrder.OrderID, 10)})
			return httptesting.BuildResponseString(http.StatusOK, string(unfilledFile)), nil
		})

		acct, err := ex.SubmitOrder(context.Background(), reqLimitOrder)
		assert.NoError(err)
		assert.Equal(expOrder, acct)
	})

	// TODO: add market buy, limit maker

	t.Run("error on query open orders", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		placeOrderFile, err := os.ReadFile("bitgetapi/v2/testdata/place_order_request.json")
		assert.NoError(err)

		transport.POST(placeOrderUrl, func(req *http.Request) (*http.Response, error) {
			raw, err := io.ReadAll(req.Body)
			assert.NoError(err)

			reqq := &NewOrder{}
			err = json.Unmarshal(raw, &reqq)
			assert.NoError(err)
			assert.Equal(&NewOrder{
				ClientOid: expOrder.ClientOrderID,
				Force:     string(v2.OrderForceGTC),
				OrderType: string(v2.OrderTypeLimit),
				Price:     "66000.00",
				Side:      string(v2.SideTypeBuy),
				Size:      "0.000090",
				Symbol:    expBtcSymbol,
			}, reqq)

			return httptesting.BuildResponseString(http.StatusOK, string(placeOrderFile)), nil
		})

		unfilledFile, err := os.ReadFile("bitgetapi/v2/testdata/request_error.json")
		assert.NoError(err)

		transport.GET(openOrderUrl, func(req *http.Request) (*http.Response, error) {
			query := req.URL.Query()
			assert.Len(query, 1)
			assert.Contains(query, "orderId")
			assert.Equal(query["orderId"], []string{strconv.FormatUint(expOrder.OrderID, 10)})
			return httptesting.BuildResponseString(http.StatusBadRequest, string(unfilledFile)), nil
		})

		_, err = ex.SubmitOrder(context.Background(), reqLimitOrder)
		assert.ErrorContains(err, "failed to query open order")
	})

	t.Run("unexpected client order id", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		placeOrderFile, err := os.ReadFile("bitgetapi/v2/testdata/place_order_request.json")
		assert.NoError(err)

		transport.POST(placeOrderUrl, func(req *http.Request) (*http.Response, error) {
			raw, err := io.ReadAll(req.Body)
			assert.NoError(err)

			reqq := &NewOrder{}
			err = json.Unmarshal(raw, &reqq)
			assert.NoError(err)
			assert.Equal(&NewOrder{
				ClientOid: expOrder.ClientOrderID,
				Force:     string(v2.OrderForceGTC),
				OrderType: string(v2.OrderTypeLimit),
				Price:     "66000.00",
				Side:      string(v2.SideTypeBuy),
				Size:      "0.000090",
				Symbol:    expBtcSymbol,
			}, reqq)

			apiResp := &v2.APIResponse{}
			err = json.Unmarshal(placeOrderFile, &apiResp)
			assert.NoError(err)
			placeOrderResp := &v2.PlaceOrderResponse{}
			err = json.Unmarshal(apiResp.Data, &placeOrderResp)
			assert.NoError(err)
			// remove the client order id to test
			placeOrderResp.ClientOrderId = ""

			return httptesting.BuildResponseString(http.StatusOK, string(placeOrderFile)), nil
		})

		_, err = ex.SubmitOrder(context.Background(), reqLimitOrder)
		assert.ErrorContains(err, "failed to query open order")
	})

	t.Run("failed to place order", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		placeOrderFile, err := os.ReadFile("bitgetapi/v2/testdata/place_order_request.json")
		assert.NoError(err)

		transport.POST(placeOrderUrl, func(req *http.Request) (*http.Response, error) {
			raw, err := io.ReadAll(req.Body)
			assert.NoError(err)

			reqq := &NewOrder{}
			err = json.Unmarshal(raw, &reqq)
			assert.NoError(err)
			assert.Equal(&NewOrder{
				ClientOid: expOrder.ClientOrderID,
				Force:     string(v2.OrderForceGTC),
				OrderType: string(v2.OrderTypeLimit),
				Price:     "66000.00",
				Side:      string(v2.SideTypeBuy),
				Size:      "0.000090",
				Symbol:    expBtcSymbol,
			}, reqq)

			return httptesting.BuildResponseString(http.StatusBadRequest, string(placeOrderFile)), nil
		})

		_, err = ex.SubmitOrder(context.Background(), reqLimitOrder)
		assert.ErrorContains(err, "failed to place order")
	})

	t.Run("unexpected client order id", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		reqOrder2 := reqLimitOrder
		reqOrder2.ClientOrderID = strings.Repeat("s", maxOrderIdLen+1)
		_, err := ex.SubmitOrder(context.Background(), reqOrder2)
		assert.ErrorContains(err, "unexpected length of client order id")
	})

	t.Run("time-in-force unsupported", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		reqOrder2 := reqLimitOrder
		reqOrder2.TimeInForce = types.TimeInForceIOC
		_, err := ex.SubmitOrder(context.Background(), reqOrder2)
		assert.ErrorContains(err, "not supported")

		reqOrder2.TimeInForce = types.TimeInForceFOK
		_, err = ex.SubmitOrder(context.Background(), reqOrder2)
		assert.ErrorContains(err, "not supported")
	})

	t.Run("unexpected side", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		reqOrder2 := reqLimitOrder
		reqOrder2.Side = "GG"
		_, err := ex.SubmitOrder(context.Background(), reqOrder2)
		assert.ErrorContains(err, "not supported")
	})

	t.Run("unexpected side", func(t *testing.T) {
		transport := &httptesting.MockTransport{}
		ex.client.HttpClient.Transport = transport

		reqOrder2 := reqLimitOrder
		reqOrder2.Type = "GG"
		_, err := ex.SubmitOrder(context.Background(), reqOrder2)
		assert.ErrorContains(err, "not supported")
	})
}