# Install the Bybit SDK if not already present.
!pip install pybit --quiet

from pybit.unified_trading import HTTP
import warnings

# Suppress all warnings for cleaner output in a demonstration context.
warnings.filterwarnings("ignore")

def create_client(api_key: str, api_secret: str, testnet: bool = True) -> HTTP:
    """Create and return an authenticated Bybit HTTP client.

    Parameters
    ----------
    api_key    : Your Bybit API key.
    api_secret : Your Bybit API secret.
    testnet    : If True, connects to the Bybit testnet (safe for learning).

    Returns
    -------
    HTTP: Authenticated Bybit Unified Trading HTTP client.
    """
    # Bybit's unified_trading.HTTP handles both linear and derivatives.
    client = HTTP(
        demo    = testnet,
        api_key    = api_key,
        api_secret = api_secret,
    )
    return client

# ── Replace with your own keys ──────────────────────────────────────────────
API_KEY    = "FDWUIcA8pcbJrOX0Cf"
API_SECRET = "hUe8ElOdfFNcTSf177o4elDV8ndHqY47R4ES"
# ────────────────────────────────────────────────────────────────────────────

# Create the client (testnet = True by default).
client = create_client(API_KEY, API_SECRET, testnet=True)
print("Bybit client created successfully.")

def get_ticker_price(client: HTTP, symbol: str, category: str = "linear") -> dict:
    """Return the best bid and ask price for a symbol.

    Parameters
    ----------
    client   : Authenticated Bybit HTTP client.
    symbol   : Instrument symbol, e.g. 'BTCUSDT'.
    category : Market category: 'linear', 'linear', 'inverse', or 'option'.

    Returns
    -------
    dict: Contains 'bid' and 'ask' as floats.
    """
    # get_tickers returns a list; we take the first match for our symbol.
    response = client.get_tickers(category=category, symbol=symbol)
    data = response["result"]["list"][0]
    return {
        "bid": float(data["bid1Price"]),
        "ask": float(data["ask1Price"]),
    }

# Fetch the current BTCUSDT linear ticker.
# Commented out to run locally with dummy data
# ticker = get_ticker_price(client, "BTCUSDT", category="linear")

ticker = {"bid": 60000.00, "ask": 60005.00} # Dummy data

print(f"BTCUSDT — Bid: {ticker['bid']:,.2f} | Ask: {ticker['ask']:,.2f}")

def get_order_book(client: HTTP, symbol: str, category: str = "linear", depth: int = 5) -> dict:
    """Return the top N bid and ask levels from the order book.

    Parameters
    ----------
    client   : Authenticated Bybit HTTP client.
    symbol   : Instrument symbol, e.g. 'BTCUSDT'.
    category : Market category: 'linear', 'linear', etc.
    depth    : Number of price levels to retrieve (default: 5).

    Returns
    -------
    dict: Contains 'bids' and 'asks' as lists of [price, quantity].
    """
    # get_orderbook returns bids and asks; each entry is [price, qty].
    response = client.get_orderbook(category=category, symbol=symbol, limit=depth)
    data = response["result"]
    return {
        "bids": [[float(b[0]), float(b[1])] for b in data["b"][:depth]],
        "asks": [[float(a[0]), float(a[1])] for a in data["a"][:depth]],
    }

# Display the top 5 levels of the BTCUSDT order book.
# Commented out to run locally with dummy data
# book = get_order_book(client, "BTCUSDT", category="linear", depth=5)

book = {  # Dummy data
    "bids": [[59999.5, 0.512], [59999.0, 1.204], [59998.5, 0.880], [59998.0, 2.001], [59997.5, 0.330]],
    "asks": [[60000.5, 0.470], [60001.0, 1.150], [60001.5, 0.905], [60002.0, 1.760], [60002.5, 0.290]],
}

print("Top 5 Asks (sell side):")
for price, qty in reversed(book["asks"]):
    print(f"  {price:>12,.2f}  |  {qty:.6f} BTC")

print("-" * 35)
print("Top 5 Bids (buy side):")
for price, qty in book["bids"]:
    print(f"  {price:>12,.2f}  |  {qty:.6f} BTC")

def get_trade_fee(client: HTTP, symbol: str, category: str = "linear") -> dict:
    """Return maker and taker fee rates for a symbol.

    Parameters
    ----------
    client   : Authenticated Bybit HTTP client.
    symbol   : Instrument symbol, e.g. 'BTCUSDT'.
    category : Market category: 'linear', 'linear', etc.

    Returns
    -------
    dict: Contains 'maker_fee' and 'taker_fee' as floats.

    Note: The /v5/account/fee-rate endpoint is NOT supported on Bybit
    Demo Trading accounts and will return ErrCode 10005 regardless of
    API key permissions. It works normally on real (mainnet) accounts.
    """
    # get_fee_rates returns the account's actual fee schedule.
    response = client.get_fee_rates(category=category, symbol=symbol)
    data = response["result"]["list"][0]
    return {
        "maker_fee": float(data["makerFeeRate"]),
        "taker_fee": float(data["takerFeeRate"]),
    }

# Display linear fee rates for BTCUSDT.
# Commented out: not supported on demo accounts (ErrCode 10005)
# fees = get_trade_fee(client, "BTCUSDT", category="linear")

fees = {"maker_fee": 0.0001, "taker_fee": 0.0006}  # Dummy data (VIP0 default rates)

print(f"BTCUSDT Fees — Maker: {fees['maker_fee']*100:.4f}% | Taker: {fees['taker_fee']*100:.4f}%")

def place_market_order(
    client: HTTP, symbol: str, side: str, qty: float, category: str = "linear"
) -> dict:
    """Place a market order on Bybit.

    Parameters
    ----------
    client   : Authenticated Bybit HTTP client.
    symbol   : Instrument symbol, e.g. 'BTCUSDT'.
    side     : 'Buy' or 'Sell' (Bybit uses title case).
    qty      : Order quantity in base currency.
    category : Market category: 'linear', 'linear', etc.

    Returns
    -------
    dict: Bybit order response including orderId.
    """
    # place_order with orderType='Market' for immediate execution.
    response = client.place_order(
        category  = category,
        symbol    = symbol,
        side      = side.capitalize(),
        orderType = "Market",
        qty       = str(qty),
    )
    return response["result"]

# Place a market BUY order for 0.001 BTC on the testnet/demo.
# Commented out to run locally with dummy data
# market_order = place_market_order(
#     client, symbol="BTCUSDT", side="Buy", qty=0.001, category="linear"
# )

market_order = {"orderId": "dummy-market-0001", "orderLinkId": "dummy-link-0001"}  # Dummy data

print("Market Order Placed:")
print(f"  Order ID : {market_order['orderId']}")
print(f"  Order Link ID: {market_order.get('orderLinkId', 'N/A')}")

def place_limit_order(
    client: HTTP, symbol: str, side: str, qty: float, price: float, category: str = "linear"
) -> dict:
    """Place a limit order on Bybit (Good-Till-Cancelled by default).

    Parameters
    ----------
    client   : Authenticated Bybit HTTP client.
    symbol   : Instrument symbol, e.g. 'BTCUSDT'.
    side     : 'Buy' or 'Sell' (Bybit uses title case).
    qty      : Order quantity in base currency.
    price    : Limit price at which to execute.
    category : Market category: 'linear', 'linear', etc.

    Returns
    -------
    dict: Bybit order response including orderId.
    """
    # place_order with orderType='Limit' rests until filled or cancelled.
    response = client.place_order(
        category  = category,
        symbol    = symbol,
        side      = side.capitalize(),
        orderType = "Limit",
        qty       = str(qty),
        price     = str(price),
        timeInForce = "GTC",
    )
    return response["result"]

# Place a passive limit BUY 1% below the current ask.
# Commented out to run locally with dummy data
# current_ask = get_ticker_price(client, "BTCUSDT", category="linear")["ask"]
current_ask = ticker["ask"]  # reuse dummy ticker from earlier
limit_price  = round(current_ask * 0.99, 2)

# limit_order = place_limit_order(
#     client, symbol="BTCUSDT", side="Buy", qty=0.001, price=limit_price, category="linear"
# )

limit_order = {"orderId": "dummy-limit-0001", "orderLinkId": "dummy-link-0002"}  # Dummy data

print("Limit Order Placed:")
print(f"  Order ID   : {limit_order['orderId']}")
print(f"  Limit Price: {limit_price:,.2f} USDT")

def get_order_status(client: HTTP, symbol: str, order_id: str, category: str = "linear") -> dict:
    """Return the status and fill details of an existing order.

    Parameters
    ----------
    client   : Authenticated Bybit HTTP client.
    symbol   : Instrument symbol, e.g. 'BTCUSDT'.
    order_id : The order ID string returned when the order was placed.
    category : Market category: 'linear', 'linear', etc.

    Returns
    -------
    dict: Contains 'order_status', 'cum_exec_qty', and 'avg_price'.
    """
    # get_open_orders and get_order_history can both be used; history for closed orders.
    response = client.get_open_orders(category=category, symbol=symbol, orderId=order_id)
    orders = response["result"]["list"]

    if not orders:
        # Order may be closed — check order history.
        response = client.get_order_history(category=category, symbol=symbol, orderId=order_id)
        orders = response["result"]["list"]

    data = orders[0]
    return {
        "order_status": data["orderStatus"],
        "cum_exec_qty": float(data["cumExecQty"]),
        "avg_price"   : float(data["avgPrice"]) if data["avgPrice"] else 0.0,
    }

# Check the status of the limit order we placed.
# Commented out to run locally with dummy data
# status = get_order_status(client, "BTCUSDT", limit_order["orderId"], category="linear")

status = {"order_status": "New", "cum_exec_qty": 0.0, "avg_price": 0.0}  # Dummy data

print("Limit Order Status:")
print(f"  Status       : {status['order_status']}")
print(f"  Executed Qty : {status['cum_exec_qty']} BTC")
print(f"  Avg Fill Price: {status['avg_price']:,.2f} USDT")

def cancel_order(client: HTTP, symbol: str, order_id: str, category: str = "linear") -> dict:
    """Cancel an open order on Bybit.

    Parameters
    ----------
    client   : Authenticated Bybit HTTP client.
    symbol   : Instrument symbol, e.g. 'BTCUSDT'.
    order_id : The order ID string to cancel.
    category : Market category: 'linear', 'linear', etc.

    Returns
    -------
    dict: Cancellation confirmation from Bybit.
    """
    # cancel_order raises an error if the order is already filled or cancelled.
    response = client.cancel_order(category=category, symbol=symbol, orderId=order_id)
    return response["result"]

# Cancel the limit order if it is still open.
# Commented out to run locally with dummy data
# cancel_result = cancel_order(client, "BTCUSDT", limit_order["orderId"], category="linear")

cancel_result = {"orderId": limit_order["orderId"], "orderLinkId": limit_order.get("orderLinkId", "N/A")}  # Dummy data

print("Order Cancelled:")
print(f"  Order ID : {cancel_result['orderId']}")
print(f"  Order Link ID: {cancel_result.get('orderLinkId', 'N/A')}")