# Install the Binance client library if not already present.
!pip install python-binance --quiet

from binance.client import Client
from binance.enums import (
    SIDE_BUY, SIDE_SELL,
    ORDER_TYPE_MARKET, ORDER_TYPE_LIMIT,
    TIME_IN_FORCE_GTC,
)
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) -> Client:
    """Create and return an authenticated Binance client.

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

    Returns
    -------
    Client: Authenticated Binance client instance.
    """
    # Initialise client; testnet flag routes requests to the test environment.
    client = Client(api_key, api_secret, testnet=testnet)
    return client

# ── Replace with your own keys ──────────────────────────────────────────────
API_KEY    = "YOUR_BINANCE_API_KEY"
API_SECRET = "YOUR_BINANCE_API_SECRET"
# ────────────────────────────────────────────────────────────────────────────

# Create the client (testnet = True by default).
# Commented out to run locally without network access / real keys
# client = create_client(API_KEY, API_SECRET, testnet=True)

client = None  # Dummy placeholder client (no live connection in this offline run)
print("Binance client created successfully.")

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

    Parameters
    ----------
    client : Authenticated Binance client.
    symbol : Trading pair symbol, e.g. 'BTCUSDT'.

    Returns
    -------
    dict: Contains 'bid' and 'ask' as floats.
    """
    # get_orderbook_ticker returns the best bid and ask for the symbol.
    ticker = client.get_orderbook_ticker(symbol=symbol)
    return {
        "bid": float(ticker["bidPrice"]),
        "ask": float(ticker["askPrice"]),
    }

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

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: Client, symbol: str, depth: int = 5) -> dict:
    """Return the top N bid and ask levels from the order book.

    Parameters
    ----------
    client : Authenticated Binance client.
    symbol : Trading pair symbol, e.g. 'BTCUSDT'.
    depth  : Number of price levels to retrieve (default: 5).

    Returns
    -------
    dict: Contains 'bids' and 'asks' as lists of [price, quantity].
    """
    # get_order_book returns a dict with 'bids' and 'asks' lists.
    book = client.get_order_book(symbol=symbol, limit=depth)
    return {
        "bids": [[float(p), float(q)] for p, q in book["bids"]],
        "asks": [[float(p), float(q)] for p, q in book["asks"]],
    }

# Display the top 5 levels of the BTCUSDT order book.
# Commented out to run locally with dummy data
# book = get_order_book(client, "BTCUSDT", 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: Client, symbol: str) -> dict:
    """Return maker and taker fee rates for a symbol.

    Parameters
    ----------
    client : Authenticated Binance client.
    symbol : Trading pair symbol, e.g. 'BTCUSDT'.

    Returns
    -------
    dict: Contains 'maker_fee' and 'taker_fee' as floats (e.g., 0.001 = 0.1%).
    """
    # get_trade_fee returns a list of fee objects; we extract the first match.
    fees = client.get_trade_fee(symbol=symbol)
    fee_info = fees[0] if fees else {"makerCommission": 0.001, "takerCommission": 0.001}
    return {
        "maker_fee": float(fee_info.get("makerCommission", 0.001)),
        "taker_fee": float(fee_info.get("takerCommission", 0.001)),
    }

# Display the fee rates for BTCUSDT.
# Commented out to run locally with dummy data
# fees = get_trade_fee(client, "BTCUSDT")

fees = {"maker_fee": 0.0002, "taker_fee": 0.0004}  # Dummy data (default Binance VIP0 rates)

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

def place_market_order(client: Client, symbol: str, side: str, quantity: float) -> dict:
    """Place a market order on Binance.

    Parameters
    ----------
    client   : Authenticated Binance client.
    symbol   : Trading pair symbol, e.g. 'BTCUSDT'.
    side     : 'BUY' or 'SELL'.
    quantity : Amount of base asset to buy or sell.

    Returns
    -------
    dict: Full order response from Binance including orderId and fills.
    """
    # Map string side to the Binance enum constant.
    binance_side = SIDE_BUY if side.upper() == "BUY" else SIDE_SELL

    # Submit the market order via the REST API.
    order = client.order_market(
        symbol=symbol,
        side=binance_side,
        quantity=quantity,
    )
    return order

# Place a market BUY order for 0.001 BTC on the testnet.
# Commented out to run locally with dummy data
# market_order = place_market_order(client, "BTCUSDT", side="BUY", quantity=0.001)

market_order = {  # Dummy data
    "orderId": 100001,
    "symbol": "BTCUSDT",
    "side": "BUY",
    "status": "FILLED",
    "executedQty": "0.00100000",
}

print("Market Order Placed:")
print(f"  Order ID  : {market_order['orderId']}")
print(f"  Symbol    : {market_order['symbol']}")
print(f"  Side      : {market_order['side']}")
print(f"  Status    : {market_order['status']}")
print(f"  Qty Filled: {market_order['executedQty']} BTC")

def place_limit_order(
    client: Client, symbol: str, side: str, quantity: float, price: float
) -> dict:
    """Place a limit order on Binance (Good-Till-Cancelled).

    Parameters
    ----------
    client   : Authenticated Binance client.
    symbol   : Trading pair symbol, e.g. 'BTCUSDT'.
    side     : 'BUY' or 'SELL'.
    quantity : Amount of base asset to buy or sell.
    price    : Limit price at which to execute.

    Returns
    -------
    dict: Full order response from Binance including orderId.
    """
    # Map string side to the Binance enum constant.
    binance_side = SIDE_BUY if side.upper() == "BUY" else SIDE_SELL

    # Submit the limit GTC order; it will rest in the book until filled or cancelled.
    order = client.order_limit(
        symbol=symbol,
        side=binance_side,
        quantity=quantity,
        price=str(price),
        timeInForce=TIME_IN_FORCE_GTC,
    )
    return order

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

# limit_order = place_limit_order(
#     client, "BTCUSDT", side="BUY", quantity=0.001, price=limit_price
# )

limit_order = {  # Dummy data
    "orderId": 100002,
    "symbol": "BTCUSDT",
    "side": "BUY",
    "status": "NEW",
}

print("Limit Order Placed:")
print(f"  Order ID   : {limit_order['orderId']}")
print(f"  Symbol     : {limit_order['symbol']}")
print(f"  Side       : {limit_order['side']}")
print(f"  Limit Price: {limit_price:,.2f} USDT")
print(f"  Status     : {limit_order['status']}")

def get_order_status(client: Client, symbol: str, order_id: int) -> dict:
    """Return the status of an existing order.

    Parameters
    ----------
    client   : Authenticated Binance client.
    symbol   : Trading pair symbol, e.g. 'BTCUSDT'.
    order_id : The integer order ID returned when the order was placed.

    Returns
    -------
    dict: Contains 'status', 'executed_qty', and 'avg_price'.
    """
    # Query the order by symbol and ID.
    order = client.get_order(symbol=symbol, orderId=order_id)
    executed_qty = float(order["executedQty"])
    avg_price    = (
        float(order["cummulativeQuoteQty"]) / executed_qty
        if executed_qty > 0 else 0.0
    )
    return {
        "status"      : order["status"],
        "executed_qty": executed_qty,
        "avg_price"   : round(avg_price, 2),
    }

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

status = {"status": "NEW", "executed_qty": 0.0, "avg_price": 0.0}  # Dummy data

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

def cancel_order(client: Client, symbol: str, order_id: int) -> dict:
    """Cancel an open order on Binance.

    Parameters
    ----------
    client   : Authenticated Binance client.
    symbol   : Trading pair symbol, e.g. 'BTCUSDT'.
    order_id : The integer order ID to cancel.

    Returns
    -------
    dict: Cancellation confirmation from Binance.
    """
    # Send the cancel request; raises an exception if the order is already filled.
    result = client.cancel_order(symbol=symbol, orderId=order_id)
    return 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"])

cancel_result = {"orderId": limit_order["orderId"], "status": "CANCELED"}  # Dummy data

print("Order Cancelled:")
print(f"  Order ID : {cancel_result['orderId']}")
print(f"  Status   : {cancel_result['status']}")