arbitrage/checker/erc20_to_mexc_checker_ws.py

import requests
import time
import threading
import json
import logging
import ok_chain_client # 假设这是你的 OKX Chain 客户端库
import pprint
import plotly.graph_objects as go
import argparse
import signal
import traceback
import copy

from pprint import pformat
from decimal import Decimal, ROUND_DOWN
from mexc_ws_client import MexcWSClient
from typing import Callable, Any, Dict, List, Tuple
from flask import Flask, render_template, jsonify
from collections import deque
from plotly.utils import PlotlyJSONEncoder

# configs
from config import wallet
from config import okchain_api
from config import arb

# 排序及深度處理
import bisect
from typing import List

# logs
from logger_config import get_logger
logger = get_logger('as')

# ok web3的配置
ok_chain_client.api_config = okchain_api # 假设ok_chain_client有此配置方式

# --- 配置 arb_executor.py 的 HTTP 地址和端口 ---
ARB_EXECUTOR_URL = arb["ARB_EXECUTOR_URL"]

# --- 配置部分 ---
# IN_AMOUNT_TO_QUERY 将在循环中动态确定
EXCHANGE_OUT_AMOUNT = Decimal(str(arb["EXCHANGE_OUT_AMOUNT"])) # 确保是Decimal
PROFIT_LIMIT = Decimal(str(arb["PROFIT_LIMIT"])) # 确保是Decimal
IN_TOKEN_ADDRESS = arb["IN_TOKEN_ADDRESS"]
IN_TOKEN_DECIMALS = arb["IN_TOKEN_DECIMALS"]
OUT_TOKEN_ADDRESS = arb["OUT_TOKEN_ADDRESS"]
SLIPPAGE = arb["SLIPPAGE"]
MEXC_TARGET_PAIR_USDT = arb["MEXC_TARGET_PAIR_USDT"]
CHAIN_ID = arb["CHAIN_ID"]

# 錢包的配置
USER_WALLET = wallet["user_wallet"]
USER_EXCHANGE_WALLET = wallet["user_exchange_wallet"]

proxies = None # {'http': 'http://proxy_url:port', 'https': 'http://proxy_url:port'}

# 運行模式【trade、view】
mode = None
# oo_price_usdt_per_target = None # 这个全局变量似乎没有被有效使用，价格在循环内获取

# 配置請求的日志等級
app = Flask(__name__)
log = logging.getLogger('werkzeug')
log.setLevel(logging.ERROR)

REFRESH_INTERVAL_SECONDS = 1 # 稍微增加间隔以减少API调用频率
MAX_HISTORY_POINTS_PLOTLY = 21600
historical_data_points = deque(maxlen=MAX_HISTORY_POINTS_PLOTLY)

TARGET_ASSET_SYMBOL = MEXC_TARGET_PAIR_USDT.split('_')[0] # e.g., RATO
BASE_CURRENCY_SYMBOL = MEXC_TARGET_PAIR_USDT.split('_')[1] # e.g., USDT (assumed to be consistent with IN_TOKEN_ADDRESS)

# --- 全局深度数据和锁 ---
# 初始化一个空的深度结构
depth: Dict[str, Any] = {
    "lastUpdateId": None, # 可以考虑用事件ID或时间戳更新
    "bids": [], # 列表中的每个元素是 [price_str, volume_str]
    "asks": []  # 列表中的每个元素是 [price_str, volume_str]
}
depth_lock = threading.Lock() # 用于保护对 depth 数据的并发访问

 # 對於每次深度數據更新，都至少要更新一下該變量
in_amount_to_query_human = Decimal(300)
in_amount_lock = threading.Lock()

# 鏈上數據的構造鎖結構
chain_data = {}
chain_data_lock = threading.Lock()

# 圖表數據
latest_values_for_table = {
    f"oo_price_usdt_per_target": "N/A",
    f"mexc_price_target_per_base": "N/A", # MEXC Bid1 (converted to USDT/TARGET)
    f"diff_oo_vs_mexc_bid1_percentage": "N/A",
    "profit_value_for_table": "N/A", # 新增：用于表格的利润值
    "oo_error": None, "mexc_error": None,
    "last_updated": "N/A",
    "mexc_pair_usdt_for_display": MEXC_TARGET_PAIR_USDT,
    "target_asset_symbol_for_display": TARGET_ASSET_SYMBOL,
    "base_currency_symbol_for_display": BASE_CURRENCY_SYMBOL
}
data_lock = threading.Lock()

# 1秒一次添加數據到圖表
last_insert_time = 0
last_insert_time_lock = threading.Lock()

# --- 兩個綫程，分別獲取depth以及鏈上數據
def update_depth_data_periodically():
    global depth
    while True:
        # 等待 1 分鐘
        time.sleep(60)

        try:
            new_depth = get_depth(MEXC_TARGET_PAIR_USDT)

            if 'bids' in new_depth and new_depth['bids']:
                with depth_lock:
                    depth = new_depth
            else:
                logger.error(f"depth獲取失敗: {new_depth}")
        except Exception as e:
            # 捕获线程循环中的其他潜在错误
            logger.error(f"depth数据更新线程发生未知错误: {e}")
            traceback.print_exc()

def update_chain_data_periodically():
    global chain_data

    chain_id = CHAIN_ID
    in_token_addr = IN_TOKEN_ADDRESS
    out_token_addr = OUT_TOKEN_ADDRESS
    in_token_decimals = IN_TOKEN_DECIMALS
    slippage = SLIPPAGE
    user_wallet_addr = USER_WALLET
    user_exchange_wallet_addr = USER_EXCHANGE_WALLET

    while True:
        try:
            with in_amount_lock:
                amount_in_base_human = Decimal(str(in_amount_to_query_human))

            in_token_amount_atomic = int(amount_in_base_human * (10 ** in_token_decimals)) # 转为原子单位整数
            data = ok_chain_client.swap(chain_id, in_token_amount_atomic, in_token_addr, out_token_addr, slippage, user_wallet_addr, user_exchange_wallet_addr, 'fast')

            if data.get('code') == '0' and data.get('data'):
                with chain_data_lock:
                    chain_data = data
            else:
                logger.info(f"鏈上數據獲取錯誤:{data}")
        except Exception as e:
            # 捕获线程循环中的其他潜在错误
            logger.error(f"鏈上数据更新线程发生未知错误: {e}")
            traceback.print_exc()
        
        # 等待 0.1 秒 測試
        time.sleep(0.1)

# --- 深度维护逻辑 ---
def update_level(levels_list: List[List[str]], price_str: str, volume_str: str, is_bids: bool):
    """
    高效更新单个订单簿边（bids 或 asks）的特定价格水平。

    Args:
        levels_list: 当前的 bids 或 asks 列表，已按价格排序（bids 降序，asks 升序）。
        price_str:   新价格 (字符串)。
        volume_str:  新数量 (字符串)。
        is_bids:     布尔值，True 表示 bids (按价格降序)，False 表示 asks (按价格升序)。
    """
    price_to_update = float(price_str)
    volume_to_update = float(volume_str)
    new_level_entry = [price_str, volume_str]

    # 1. 尝试查找现有的价格水平 (线性扫描，但对于深度有限的列表通常够快)
    #    如果深度非常大 (几百上千档)，则二分查找会更好。
    found_at_index = -1
    for i, level_data in enumerate(levels_list):
        if float(level_data[0]) == price_to_update:
            found_at_index = i
            break

    # 2. 如果数量为0，则移除
    if volume_to_update == 0.0:
        if found_at_index != -1:
            levels_list.pop(found_at_index)
    # 3. 如果数量不为0
    else:
        if found_at_index != -1:  # 价格已存在，更新数量
            levels_list[found_at_index][1] = volume_str
        else:  # 价格不存在，需要插入以保持排序
            if is_bids:
                # Bids: 价格降序 (高价在前)
                # 找到插入点：第一个使得 level_price <= price_to_update 的位置
                insert_idx = 0
                while insert_idx < len(levels_list) and float(levels_list[insert_idx][0]) > price_to_update:
                    insert_idx += 1
                levels_list.insert(insert_idx, new_level_entry)
            else:
                # Asks: 价格升序 (低价在前)
                # 找到插入点：第一个使得 level_price >= price_to_update 的位置
                # 使用 bisect.bisect_left 获取 prices (只包含价格的列表) 的插入点
                # 如果不创建临时 prices 列表，也可以直接迭代：
                insert_idx = 0
                while insert_idx < len(levels_list) and float(levels_list[insert_idx][0]) < price_to_update:
                    insert_idx += 1
                levels_list.insert(insert_idx, new_level_entry)

def update_depth_from_incremental(message_data: Dict[str, Any]):
    """
    根据增量深度消息更新全局 depth 结构。

    Args:
        message_data (Dict[str, Any]): 从 WebSocket 收到的已解析的JSON数据，
                                      期望包含 'c' (channel) 和 'd' (data) 字段。
                                      'd' 应该包含 'bids' 和/或 'asks' 以及 'r' (推流ID)。
    """
    global depth, depth_lock

    # 检查是否是我们期望的增量深度消息
    channel = message_data.get('c')
    if not channel or "spot@public.increase.depth.v3.api" not in channel:
        # print(f"[DEPTH_UPDATE] Received non-depth message or unexpected channel: {channel}")
        return

    data_part = message_data.get('d')
    if not data_part or not isinstance(data_part, dict):
        print(f"[DEPTH_UPDATE] Incremental depth message 'd' part is missing or not a dict: {message_data}")
        return

    # 获取推流 ID，用于更新 lastUpdateId (如果需要严格同步，这里可能需要更复杂的逻辑)
    # r = message_data['d'].get('r') # 这个 'r' 是MEXC的推流编号, 不是UpdateID
    # 对于MEXC，增量深度通常不直接提供严格意义上的 Binance 那样的 U (firstUpdateId) 和 u (finalUpdateId)
    # 如果需要严格校对，通常需要先拉取一次全量快照，然后基于快照的 eventId/versionId 来应用增量
    # 这里我们简单地用最新的推流ID r (如果可用) 或者 时间戳 来标记更新
    # MEXC的 `spot@public.increase.depth.v3.api` 返回的 `r` 字段是唯一的推流ID。

    stream_id = data_part.get('r') # 这个r是推流ID，可以用它来粗略判断顺序

    # 更新 lastUpdateId (用推流ID或时间戳)
    if stream_id:
        # 注意：如果 depth['lastUpdateId'] 之前是全量快照的 eventId，
        # 那么这里的推流ID r 的序列性需要搞清楚。
        # 如果只是简单地取最大值，那也可以。
        with depth_lock:
            if depth.get("lastUpdateId") is None or int(stream_id) > int(depth.get("lastUpdateId", 0)):
                    depth["lastUpdateId"] = stream_id
    else:
        with depth_lock:
            depth["lastUpdateId"] = int(time.time() * 1000) # 或者使用时间戳

    # 更新 bids
    if 'bids' in data_part and isinstance(data_part['bids'], list):
        for bid_update in data_part['bids']:
            if isinstance(bid_update, dict) and 'p' in bid_update and 'v' in bid_update:
                with depth_lock:
                    update_level(depth['bids'], bid_update['p'], bid_update['v'], is_bids=True)

                # 如果更新的是買盤數據，則執行數據更新流程
                update_data_for_plotly_and_table()
            else:
                print(f"[DEPTH_UPDATE] Invalid bid update format: {bid_update}")

    # 更新 asks，該策略的賣盤數據不處理
    # if 'asks' in data_part and isinstance(data_part['asks'], list):
    #     for ask_update in data_part['asks']:
    #         if isinstance(ask_update, dict) and 'p' in ask_update and 'v' in ask_update:
    #             with depth_lock:
    #                 update_level(depth['asks'], ask_update['p'], ask_update['v'], is_bids=False)
    #         else:
    #             print(f"[DEPTH_UPDATE] Invalid ask update format: {ask_update}")

    # 可选：限制深度列表的长度，例如只保留前N档
    # with depth_lock:
    # depth['bids'] = depth['bids'][:50]
    # depth['asks'] = depth['asks'][:50]

    # # 打印更新后的深度信息 (用于调试)
    # delay = time.time() * 1000 - message_data['t']
    # print_current_depth(delay)

def print_current_depth(delay, max_levels_to_print=5):
    """打印当前深度信息 (前几档)"""
    with depth_lock:
        print(f"--- Current Depth (lastUpdateId: {depth.get('lastUpdateId')}, Delay={delay}) ---")
        print("\nAsks (Price, Volume):")
        asks_to_print = depth['asks'][:max_levels_to_print]
        for i in range(len(asks_to_print) -1, -1, -1):
            price, volume = asks_to_print[i]
            print(f"  S{i+1}: {price} - {volume}") # S{原始档位号}
        if not depth['asks']:
            print("  (No asks)")
        print("--------------------------\n")
        
        print("Bids (Price, Volume):")
        for i, (price, volume) in enumerate(depth['bids'][:max_levels_to_print]):
            print(f"  B{i+1}. {price} - {volume}")
        if not depth['bids']:
            print("  (No bids)")

def get_depth(symol, limit=5000):
    url = "https://api.mexc.com/api/v3/depth"
    params = {'symbol': symol.replace('_', ''), 'limit': limit}

    try:
        r = requests.get(url, params=params, proxies=proxies, timeout=5) # 减少超时
        r.raise_for_status()
        return r.json()
    except requests.exceptions.RequestException as e:
        # logger.error(f"MEXC现货({pair_symbol})请求错误: {e}")
        return {"error": f"MEXC现货({pair_symbol})请求错误: {e}"}
    except Exception as e:
        # logger.error(f"MEXC现货({pair_symbol})处理错误: {e}", exc_info=True)
        return {"error": f"MEXC现货({pair_symbol})处理错误: {e}"}

# --- 链上价格获取函数 (Okx) ---
# 返回: price_base_per_target (例如 USDT per RATO)
def get_chain_price_vs_target_currency():
    try:        
        with chain_data_lock:
            data = copy.deepcopy(chain_data)

        if data.get('code') == '0' and data.get('data'):
            d = data['data'][0]
            router_result = d['routerResult']
            in_dec, out_dec = int(router_result['fromToken']['decimal']), int(router_result['toToken']['decimal'])
            atomic_in_base, atomic_out_target = Decimal(router_result['fromTokenAmount']), Decimal(router_result['toTokenAmount'])

            human_in_base = atomic_in_base / (10 ** in_dec)
            human_out_target = atomic_out_target / (10 ** out_dec)
            if human_out_target == 0: return {"error": f"OO输出目标代币为0 ({CHAIN_ID})"}, data # data 也返回
            return {"price_base_per_target": human_in_base / human_out_target}, data
        else:
            logger.info(f"chain數據獲取問題: {data}")
            return {
                "error": f"Okx API错误 - Code:{data.get('code', 'N/A')}, Msg:{data.get('msg', data.get('message', 'N/A')) if isinstance(data, dict) else '格式错误'}"}, None
    except Exception as e:
        logger.error(f"Okx请求错误详情: ", exc_info=True)
        return {"error": f"Okx请求错误: {e}"}, None

# MEXC 现货 (获取 目标代币/USDT 的 bid 价格)
# 返回: price_target_per_usdt_bid1 (例如 RATO per USDT)
def get_mexc_spot_price_target_usdt_bid():
    try:
        with depth_lock:
            depth_copy = copy.deepcopy(depth)

        if 'bids' in depth_copy and depth_copy['bids']: # 确保bids存在且不为空
            bids = depth_copy['bids']
            trade_volume_remaining = EXCHANGE_OUT_AMOUNT # 还需要卖出的数量 (Decimal)
            trade_value = Decimal('0') # 累计的总价值 (Decimal)
            accumulated_volume = Decimal('0') # 累计吃单量

            for orderbook in bids:
                price = Decimal(orderbook[0])
                volume = Decimal(orderbook[1])

                if trade_volume_remaining <= Decimal('0'):
                    break # 已经满足卖出量

                can_fill = min(volume, trade_volume_remaining)
                trade_value += price * can_fill
                accumulated_volume += can_fill
                trade_volume_remaining -= can_fill
            
            if accumulated_volume == Decimal('0'): # 如果一点都没卖出去
                 # logger.warning(f"MEXC无法以EXCHANGE_OUT_AMOUNT={EXCHANGE_OUT_AMOUNT}获取任何 efectiva 卖出价格，累积量为0")
                return {"error": f"MEXC订单簿深度不足以卖出{EXCHANGE_OUT_AMOUNT} {TARGET_ASSET_SYMBOL}"}, Decimal('0')

            # 计算平均卖出价格
            # sell_price 代表 1 TARGET_ASSET = X USDT
            sell_price = trade_value / accumulated_volume 
            sell_price = sell_price.quantize(Decimal('1e-15'), rounding=ROUND_DOWN)

            # trade_value 代表卖出 accumulated_volume 个 TARGET_ASSET 能得到的 USDT 总量
            return {
                "price_target_per_usdt_bid1": sell_price # 这个名字其实是 RATO/USDT，所以可以叫 price_target_per_base
            }, trade_value # 返回的是实际能卖出 EXCHANGE_OUT_AMOUNT (或更少，如果深度不足) 所得的 USDT 总额
        else:
            # logger.warning(f"MEXC现货({pair_symbol}) bids 数据不存在或为空: {data}")
            return {"error": f"MEXC现货({pair_symbol}) bids 数据不存在或为空"}, Decimal('0')
    except requests.exceptions.RequestException as e:
        # logger.error(f"MEXC现货({pair_symbol})请求错误: {e}")
        return {"error": f"MEXC现货({pair_symbol})请求错误: {e}"}, Decimal('0')
    except Exception as e:
        # logger.error(f"MEXC现货({pair_symbol})处理错误: {e}", exc_info=True)
        return {"error": f"MEXC现货({pair_symbol})处理错误: {e}"}, Decimal('0')

def calculate_percentage_diff(price_a_base_per_target, price_b_base_per_target):
    # price_a: MEXC卖价 (USDT/TARGET) - 链上买的目标币，拿到CEX卖掉
    # price_b: 链上买价 (USDT/TARGET) - 链上用USDT买目标币
    # 期望 price_a > price_b
    if price_a_base_per_target is not None and price_b_base_per_target is not None and \
       isinstance(price_a_base_per_target, Decimal) and \
       isinstance(price_b_base_per_target, Decimal) and price_b_base_per_target != 0:
        # (卖价 - 买价) / 买价
        rst = (price_a_base_per_target - price_b_base_per_target) / price_b_base_per_target
        rst = rst.quantize(Decimal('1e-6'), rounding=ROUND_DOWN) # 提高精度
        return rst
    return None

def send_arb_msg(profit_amount, chain_swap_data, mexc_price_usdt_per_target, in_amount_copy):
    # chain_swap_data 是从 get_chain_price_vs_target_currency 返回的第二个值
    if not (chain_swap_data and chain_swap_data.get('data') and chain_swap_data['data']):
        logger.error(f"套利消息发送失败：链上交易数据不完整 {chain_swap_data}")
        return

    d = chain_swap_data['data'][0]
    tx = d['tx'] # 这是预签名的交易结构体，不是tx hash
    router_result = d['routerResult']
    from_token_info = router_result['fromToken']
    to_token_info = router_result['toToken']

    in_dec, out_dec = int(from_token_info['decimal']), int(to_token_info['decimal'])
    # human_in_base 根据实际传入的 IN_AMOUNT_TO_QUERY (trade_value) 确定
    # human_out_target 是链上swap的实际输出
    atomic_out_target = Decimal(router_result['toTokenAmount'])
    human_out_target = atomic_out_target / (10 ** out_dec)

    arbitrage_data = {
        "tx": tx, # 预签名交易
        "profit": str(profit_amount.quantize(Decimal('0.001'))),
        "profitLimit": str(PROFIT_LIMIT.quantize(Decimal('0.001'))),
        # "mexcPriceUsdtPerTarget": str(mexc_price_usdt_per_target.quantize(Decimal('1e-8'))),
        "symbol": MEXC_TARGET_PAIR_USDT,
        "fromToken": IN_TOKEN_ADDRESS,
        "fromTokenAmountHuman": str(in_amount_copy.quantize(Decimal(f'1e-{in_dec}'))),
        "fromTokenDecimal": str(in_dec),
        "toToken": OUT_TOKEN_ADDRESS,
        "toTokenAmountHuman": str(human_out_target.quantize(Decimal(f'1e-{out_dec}'))),
        "toTokenDecimal": str(out_dec),
        "exchangeOutAmount": str(EXCHANGE_OUT_AMOUNT.quantize(Decimal(f'1e-{out_dec}'))), # CEX上期望卖出的目标币数量
        "strategy": "erc20_to_mexc",
    }

    logger.info(f"正在提交套利数据到 {ARB_EXECUTOR_URL}, profit {arbitrage_data["profit"]}, profitLimit {arbitrage_data["profitLimit"]}, keys: {arbitrage_data.keys()}")

    try:
        response = requests.post(ARB_EXECUTOR_URL, json=arbitrage_data, timeout=10)
        logger.info(f"套利执行器响应状态码: {response.status_code}")
        try:
            response_data = response.json()
            logger.info(f"套利执行器响应内容: {response_data}")
        except requests.exceptions.JSONDecodeError:
            logger.error(f"套利执行器响应无法解析为JSON: {response.text}")
    except requests.exceptions.RequestException as e:
        logger.error(f"连接套利执行器 {ARB_EXECUTOR_URL} 失败: {e}")
    except Exception as e:
        logger.error(f"发送套利消息未知错误: {e}", exc_info=True)

def update_data_for_plotly_and_table():
    global historical_data_points, latest_values_for_table # IN_AMOUNT_TO_QUERY
    
    fetch_time_full = time.strftime("%Y-%m-%d %H:%M:%S")
    fetch_time_chart = time.strftime("%H:%M:%S")

    # 1. MEXC: 获取 price_target_per_usdt_bid1 (例如 RATO/USDT) 和相应的 trade_value_usdt
    # trade_value_usdt 是指如果以 EXCHANGE_OUT_AMOUNT 的目标代币在MEXC上砸盘卖出，能获得的USDT估值
    mexc_data, trade_value_usdt = get_mexc_spot_price_target_usdt_bid()
    mexc_price_target_per_usdt_bid = mexc_data.get("price_target_per_usdt_bid1") # TARGET/USDT
    mexc_err = mexc_data.get("error")

    # price_target_per_usdt_bid1: 这是1个目标币能卖多少USDT, 即 USDT/TARGET
    # 所以可以直接用，不需要转换，变量名应为 mexc_price_target_per_base
    mexc_price_target_per_base = None
    if mexc_price_target_per_usdt_bid is not None and mexc_price_target_per_usdt_bid > 0:
        mexc_price_target_per_base = mexc_price_target_per_usdt_bid # RATO/USDT => USDT/TARGET (命名约定)

    elif not mexc_err and mexc_price_target_per_usdt_bid is not None:
            mexc_err = mexc_err or "MEXC价格为0或无效"
    
    if mexc_err or trade_value_usdt == Decimal('0'): # 如果MEXC有问题或无法确定砸盘价值，则跳过本次循环
        logger.warning(f"MEXC数据获取问题: {mexc_err}, trade_value_usdt: {trade_value_usdt}. 跳过本次循环。")
        with data_lock: # 依然更新错误信息
            latest_values_for_table["mexc_error"] = mexc_err
            latest_values_for_table["oo_error"] = latest_values_for_table.get("oo_error") # 保持上次的oo_error
            latest_values_for_table["last_updated"] = fetch_time_full
        time.sleep(REFRESH_INTERVAL_SECONDS)
        return

    # 2. 确定链上查询的输入金额 (USDT)
    # 使用 MEXC 卖出 EXCHANGE_OUT_AMOUNT 个目标币能得到的USDT数量 (trade_value_usdt)
    # 作为链上购买目标币时花费的USDT数量 (in_amount_to_query_human)
    # 交易所賣了多少
    global in_amount_to_query_human
    with in_amount_lock:
        in_amount_to_query_human = trade_value_usdt.quantize(Decimal('1e-2'), rounding=ROUND_DOWN) # 保留两位小数

        in_amount_copy = Decimal(str(in_amount_to_query_human))
    if in_amount_copy <= Decimal('0'):
        logger.warning(f"计算出的链上查询金额为0或负数 ({in_amount_copy} USDT)，跳过。trade_value_usdt: {trade_value_usdt}")
        time.sleep(REFRESH_INTERVAL_SECONDS)
        return

    # 3. 获取链上价格：用 in_amount_copy 这么多的USDT去买目标币，能买到多少，以及价格 (USDT/TARGET)
    oo_data, chain_swap_full_response = get_chain_price_vs_target_currency()
    oo_price_usdt_per_target = oo_data.get("price_base_per_target") # USDT/TARGET
    oo_err = oo_data.get("error")

    # 4. 计算百分比差异
    # diff = (MEXC卖价 - 链上买价) / 链上买价
    diff_oo_vs_mexc_bid1_pct = calculate_percentage_diff(
        mexc_price_target_per_base, # MEXC卖价 (USDT/TARGET)
        oo_price_usdt_per_target                  # 链上买价 (USDT/TARGET)
    )

    # 5. 计算实际利润额 (以USDT计价)
    # 利润 = (MEXC每目标币卖价 - 链上每目标币买价) * 链上买入的目标币数量
    # 链上买入的目标币数量 = in_amount_copy / oo_price_usdt_per_target
    # 简化：利润百分比 * 投入的USDT金额
    actual_profit_usdt = None
    if diff_oo_vs_mexc_bid1_pct is not None and oo_price_usdt_per_target is not None and oo_price_usdt_per_target > 0:
        # 方案A: 基于百分比和投入金额
        actual_profit_usdt = diff_oo_vs_mexc_bid1_pct * in_amount_copy

    # 6. 满足利润条件，发送套利消息, PROFIT_LIMIT + 3的3是提前計算的成本，否則一直提交
    global mode
    if actual_profit_usdt is not None and actual_profit_usdt > PROFIT_LIMIT + 3 and mode == 'trade':
        if chain_swap_full_response: # 确保有完整的链上数据
            send_arb_msg(actual_profit_usdt, chain_swap_full_response, mexc_price_target_per_base, in_amount_copy)
        else:
            logger.warning("利润满足但链上数据不完整，无法发送套利消息。")

    # 數據一秒更新一次
    global last_insert_time
    with last_insert_time_lock:
        if time.time() - 1 > last_insert_time:
            last_insert_time = time.time()
            current_point = {
                "time": fetch_time_chart,
                "oo_price_usdt_per_target": float(oo_price_usdt_per_target) if oo_price_usdt_per_target else None,
                "mexc_price_target_per_base": float(mexc_price_target_per_base) if mexc_price_target_per_base else None,
                "diff_oo_vs_mexc_bid1": float(diff_oo_vs_mexc_bid1_pct) if diff_oo_vs_mexc_bid1_pct is not None else None,
                "profit_value": float(actual_profit_usdt) if actual_profit_usdt is not None else None, # 新增：用于图表的实际利润额
            }

            with data_lock:
                historical_data_points.append(current_point)
                latest_values_for_table["oo_price_usdt_per_target"] = f"{oo_price_usdt_per_target:.8f}" if oo_price_usdt_per_target else "N/A"
                latest_values_for_table["mexc_price_target_per_base"] = f"{mexc_price_target_per_base:.8f}" if mexc_price_target_per_base else "N/A"
                latest_values_for_table["diff_oo_vs_mexc_bid1_percentage"] = f"{diff_oo_vs_mexc_bid1_pct:+.4%}" if diff_oo_vs_mexc_bid1_pct is not None else "N/A" # 显示为百分比
                latest_values_for_table["profit_value_for_table"] = f"{actual_profit_usdt:.2f} {BASE_CURRENCY_SYMBOL}" if actual_profit_usdt is not None else "N/A" # 新增
                latest_values_for_table["oo_error"] = oo_err
                latest_values_for_table["mexc_error"] = mexc_err
                latest_values_for_table["last_updated"] = fetch_time_full
                latest_values_for_table["in_amount_for_query_display"] = f"{in_amount_copy:.2f} {BASE_CURRENCY_SYMBOL}" if in_amount_copy > 0 else "N/A"

        # if oo_err or mexc_err :
        #         logger.warning(f"{fetch_time_chart} Errors: OO:{oo_err}, MEXC:{mexc_err}")

@app.route('/')
def index_plotly():
    return render_template('index_plotly_dynamic_ok.html',
                           target_asset=TARGET_ASSET_SYMBOL,
                           base_asset=BASE_CURRENCY_SYMBOL,
                           mexc_pair_usdt=MEXC_TARGET_PAIR_USDT,
                           refresh_interval_ms=REFRESH_INTERVAL_SECONDS * 1000)

@app.route('/table-data')
def get_table_data():
    with data_lock:
        # logger.info(f"Table data requested: {latest_values_for_table}")
        return jsonify(latest_values_for_table)

@app.route('/plotly-chart-data')
def get_plotly_chart_data():
    with data_lock:
        points = list(historical_data_points)
        # logger.info(f"Chart data requested, {len(points)} points.")
        if not points:
            fig = go.Figure() # Create an empty figure
            fig.update_layout(title_text="暂无数据")
            empty_json = json.loads(json.dumps(fig, cls=PlotlyJSONEncoder))
            return jsonify({
                "price_chart": empty_json,
                "diff_chart": empty_json,
                "profit_chart": empty_json # 新增：空利润图表
            })

        times = [p['time'] for p in points]
        display_target_asset = latest_values_for_table["target_asset_symbol_for_display"]
        display_base_asset = latest_values_for_table["base_currency_symbol_for_display"]

        common_xaxis_config = dict(title='时间')
        common_legend_config = dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
        # if len(times) > 1: # Plotly handles autorange for single point ok
        #     common_xaxis_config['range'] = [times[0], times[-1]]
        # else:
        common_xaxis_config['autorange'] = True

        # Price Chart
        fig_prices = go.Figure()
        fig_prices.add_trace(go.Scatter(x=times, y=[p['oo_price_usdt_per_target'] for p in points], mode='lines',
                                        name=f'Okx ({display_base_asset}/{display_target_asset})',
                                        line=dict(color='rgb(75, 192, 192)'),
                                        hovertemplate=f'<b>Okx链上价</b><br>价格: %{{y:.8f}} {display_base_asset}<extra></extra>',
                                        connectgaps=True)) # 处理None值不画线
        fig_prices.add_trace(go.Scatter(x=times, y=[p['mexc_price_target_per_base'] for p in points], mode='lines',
                                        name=f'MEXC卖1价 ({display_base_asset}/{display_target_asset})',
                                        line=dict(color='rgb(255, 99, 132)', dash='dash'),
                                        hovertemplate=f'<b>MEXC卖出价</b><br>价格: %{{y:.8f}} {display_base_asset}<extra></extra>',
                                        connectgaps=True))
        fig_prices.update_layout(title_text=f'{display_base_asset}/{display_target_asset} 价格历史',
                                 xaxis=common_xaxis_config.copy(),
                                 yaxis_title=f'价格 (1 {display_target_asset} = X {display_base_asset})',
                                 legend_title_text='平台',
                                 legend=common_legend_config.copy(), hovermode='x unified',
                                 margin=dict(l=70, r=30, t=80, b=50))

        # Percentage Difference Chart
        fig_diffs = go.Figure()
        fig_diffs.add_trace(
            go.Scatter(x=times, y=[p['diff_oo_vs_mexc_bid1'] for p in points], mode='lines', name=f'价差百分比 (MEXC卖价 vs Okx买价)',
                       line=dict(color='rgb(255, 159, 64)'),
                       hovertemplate=f'<b>(MEXC卖价-Okx买价)/Okx买价</b><br>百分比: %{{y:+.4%}}<extra></extra>', # 显示为百分比
                       connectgaps=True))
        fig_diffs.update_layout(title_text=f'价差百分比历史曲线',
                                xaxis=common_xaxis_config.copy(),
                                yaxis_title='价差百分比', legend_title_text='对比', legend=common_legend_config.copy(),
                                yaxis_zeroline=True, hovermode='x unified', margin=dict(l=70, r=30, t=80, b=50),
                                yaxis_tickformat=".4%") # y轴也显示为百分比

        # --- 新增 Profit Chart ---
        fig_profit = go.Figure()
        fig_profit.add_trace(
            go.Scatter(x=times, y=[p['profit_value'] for p in points], mode='lines', name=f'预估利润 ({display_base_asset})',
                       line=dict(color='rgb(153, 102, 255)'), # 紫色
                       hovertemplate=f'<b>预估利润</b><br>金额: %{{y:,.2f}} {display_base_asset}<extra></extra>', # 利润金额，保留2位小数
                       connectgaps=True))
        fig_profit.update_layout(title_text=f'预估利润历史 ({display_base_asset})',
                                 xaxis=common_xaxis_config.copy(),
                                 yaxis_title=f'利润 ({display_base_asset})', 
                                 legend_title_text='利润额',
                                 legend=common_legend_config.copy(),
                                 yaxis_zeroline=True, hovermode='x unified',
                                 margin=dict(l=70, r=30, t=80, b=50),
                                 yaxis_tickformat="$,.2f") # y轴格式化为货币

        combined_figure_data = {
            "price_chart": json.loads(json.dumps(fig_prices, cls=PlotlyJSONEncoder)),
            "diff_chart": json.loads(json.dumps(fig_diffs, cls=PlotlyJSONEncoder)),
            "profit_chart": json.loads(json.dumps(fig_profit, cls=PlotlyJSONEncoder)) # 新增
        }
        return jsonify(combined_figure_data)

def handle_ctrl_c(sig, frame):
    print("\nCtrl+C received. Stopping all clients...")
    for client_instance in active_clients:
        client_instance.stop()
    time.sleep(2)


if __name__ == "__main__":
    signal.signal(signal.SIGINT, handle_ctrl_c)
    signal.signal(signal.SIGTERM, handle_ctrl_c)

    logger.info("Application starting. Press Ctrl+C to stop.")

    # 加载一次全量深度
    with depth_lock:
        depth = get_depth(MEXC_TARGET_PAIR_USDT)
        # logger.info(f"depth:\n{pformat(depth, indent=2)}")

    logger.info("启动depth数据更新线程...")
    updater_thread = threading.Thread(target=update_depth_data_periodically, daemon=True)
    updater_thread.start()

    logger.info("启动chain数据更新线程...")
    updater_thread = threading.Thread(target=update_chain_data_periodically, daemon=True)
    updater_thread.start()

    # 创建并启动 WebSocket 客户端，订阅增量深度
    # 注意：选择一个有交易量的币对，例如 BTCUSDT
    SYMBOL_TO_MONITOR = MEXC_TARGET_PAIR_USDT.replace('_', '')

    # 确保订阅的是增量深度频道
    depth_subscriptions = [f"spot@public.increase.depth.v3.api@{SYMBOL_TO_MONITOR}"]

    depth_client = MexcWSClient(
        symbol=SYMBOL_TO_MONITOR,
        on_message_callback=update_depth_from_incremental, # 所有消息都给这个处理器
        subscriptions=depth_subscriptions
    )
    depth_client.start()

    parser = argparse.ArgumentParser(description='套利监控和交易脚本。')
    parser.add_argument('--mode',
                        required=True,
                        choices=['trade', 'view'], # 限制可选值
                        help='运行模式: "trade" (执行交易) 或 "view" (仅观察)')
    try:
        args = parser.parse_args()
        mode = args.mode
        logger.info(f"脚本运行模式为: {mode}")

        logger.info("应用启动...")
        logger.info(f"目标资产: {TARGET_ASSET_SYMBOL}, 计价货币: {BASE_CURRENCY_SYMBOL}")
        # IN_AMOUNT_TO_QUERY 会动态变化，初始值从配置读取，但循环中会基于MEXC的trade_value更新
        # logger.info(f"链上查询初始金额: {arb['IN_AMOUNT_TO_QUERY']} {BASE_CURRENCY_SYMBOL} -> {TARGET_ASSET_SYMBOL}")
        logger.info(f"MEXC期望卖出量 (用于计算深度和价值): {EXCHANGE_OUT_AMOUNT} {TARGET_ASSET_SYMBOL}")
        logger.info(f"利润阈值: {PROFIT_LIMIT} {BASE_CURRENCY_SYMBOL}")
        logger.info(f"MEXC现货交易对: {MEXC_TARGET_PAIR_USDT}")
        
        # data_thread = threading.Thread(target=update_data_for_plotly_and_table, daemon=True)
        # data_thread.start()

        port = arb.get("PORT", 5001) # 从配置获取端口，如果没有则默认5001
        logger.info(f"Flask 服务将在 http://0.0.0.0:{port} 上运行 (刷新间隔: {REFRESH_INTERVAL_SECONDS}s)")
        app.run(debug=False, host='0.0.0.0', port=port, use_reloader=False)

    except SystemExit: # argparse 在参数错误时会引发 SystemExit
        # parser.print_help() # argparse 默认会打印帮助信息
        logger.info("脚本因参数错误而退出。请提供 '--mode' 参数 ('trade' 或 'view')。")
    except Exception as e:
        logger.critical(f"主程序发生严重错误: {e}", exc_info=True)