# -*- coding: utf-8 -*-

from ccxt.async_support.base.exchange import Exchange
from ccxt.abstract.mt5 import ImplicitAPI
import asyncio
import hashlib
from ccxt.base.types import Any, Balances, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, OrderBooks, Trade, TradingFees, Transaction
from typing import List
from typing import List, Optional  # 添加 Optional 导入
from ccxt.base.errors import ExchangeError
from ccxt.base.errors import AuthenticationError
from ccxt.base.errors import ArgumentsRequired
from ccxt.base.errors import InsufficientFunds
from ccxt.base.errors import InvalidOrder
from ccxt.base.errors import OrderNotFound
from ccxt.base.errors import DDoSProtection
from ccxt.base.errors import RateLimitExceeded
from ccxt.base.errors import ExchangeNotAvailable
from ccxt.base.errors import InvalidNonce
from ccxt.base.decimal_to_precision import TICK_SIZE
from ccxt.base.precise import Precise


class mt5(Exchange, ImplicitAPI):
    def describe(self) -> Any:
        return self.deep_extend(super(mt5, self).describe(), {
            'id': 'mt5',
            'name': 'MT5',
            'countries': ['US'],
            'version': 'v2025.02.05-05.23',
            'rateLimit': 1000, 
            'hostname': '10.203.0.6:5000', 
            'pro': True,
            'options': {
                'host': '18.163.85.196',
                'port': 443,
                'connectTimeoutSeconds': 30,
            },
            'has': {
                'CORS': True,
                'spot': True,
                'margin': True,
                'swap': False,
                'future': False,
                'option': False,
                'cancelOrder': True,
                'createOrder': True,
                'fetchBalance': True,
                'fetchClosedOrders': True,
                'fetchMarkets': True,
                'fetchMyTrades': True,
                'fetchOHLCV': True,
                'fetchOpenOrders': True,
                'fetchOrder': True,
                'fetchOrderBook': True,
                'fetchTicker': True,
                'fetchTickers': True, 
            },
            'timeframes': {
                '1m': 1,
                '5m': 5,
                '15m': 15,
                '30m': 30,
                '1h': 60,
                '4h': 240,
                '1d': 1440,
                '1w': 10080,
                '1M': 43200,
            },
            'urls': {
                'logo': '',
                'api': {
                    'public': 'http://{hostname}',  # 直接使用具体地址
                    'private': 'http://{hostname}',
                },
                'www': 'http://{hostname}',
                'doc': ['http://{hostname}/index.html'],
            },
            'api': {
                'public': {
                    'get': {
                        'Ping': 1
                    },
                },
                'private': {
                    'get': {
                        'Connect': 10,
                        'CheckConnect': 1,
                        'Disconnect': 1,
                        'Symbols': 1,
                        'SymbolParamsMany': 1,
                        'ServerTimezone':1,
                        'AccountSummary': 1,
                        'AccountDetails': 1,
                        'SymbolList': 1,
                        'GetQuote': 1,
                        'GetQuoteMany': 1,
                        'MarketWatchMany': 1,
                        'OpenedOrders': 1,
                        'ClosedOrders': 1,
                        'OpenedOrder': 1,
                        'OrderHistory': 1,
                        'PriceHistory': 1,
                        'OrderSend': 1,
                        'OrderModify': 1,
                        'OrderClose': 1,
                        'SubscribeOhlc': 1,      # K线订阅
                        'UnsubscribeOhlc': 1,    # K线取消订阅
                        'Subscribe': 1,          # 行情订阅
                        'UnSubscribe': 1,        # 行情取消订阅
                    },
                },
            },
            'requiredCredentials': {
                'apiKey': True,
                'secret': True,
                'hostname': True,
            },
            'commonCurrencies': {},
            'exceptions': {
                'exact': {
                    'Invalid token': AuthenticationError,
                    'Connection failed': ExchangeError,
                    'Invalid symbol': ExchangeError,
                    'Invalid order': InvalidOrder,
                    'Order not found': OrderNotFound,
                },
            },
        })
    
    async def get_token(self):
        """获取或刷新 token - 异步版本"""
        if hasattr(self, 'token') and self.token:
            try:
                await self.check_connect()
                return self.token
            except Exception:
                # Token 无效，重新连接
                pass
        
        # 重新连接获取 token
        return await self.connect()

    async def connect(self):
        """连接到 MT5 账户并获取 token - 异步版本"""
        request = {
            'user': self.apiKey,
            'password': self.secret,
            'host': self.options['host'],
            'port': self.options['port'],
            'connectTimeoutSeconds': self.options['connectTimeoutSeconds'],
        }
        
        response = await self.private_get_connect(request)
        
        self.token = response
        return self.token

    async def check_connect(self):
        """检查连接状态 - 异步版本"""
        request = {
            'id': await self.get_token(),
        }
        return await self.private_get_checkconnect(request)

    async def disconnect(self):
        """断开连接"""
        if hasattr(self, 'token') and self.token:
            request = {
                'id': self.token,
            }
            try:
                await self.private_get_disconnect(request)
            except Exception:
                pass
            finally:
                self.token = None

    async def fetch_markets(self, params={}):
        """获取交易对列表 - 异步修复版本"""
        if not hasattr(self, 'token') or not self.token:
            await self.get_token()
            
        request = {
            'id': self.token,
        }
        
        try:
            response = await self.private_get_symbols(self.extend(request, params))
            
            markets = []
            if isinstance(response, dict):
                for symbol, info in response.items():
                    try:
                        market = self.parse_market(info)
                        if market and market.get('symbol'):
                            markets.append(market)
                    except Exception as e:
                        # 跳过解析失败的市场，继续处理其他市场
                        if self.verbose:
                            print(f"跳过交易对 {symbol}: {e}")
                        continue
            
            # 设置市场数据
            if markets:
                self.markets = {}
                self.symbols = []
                for market in markets:
                    id = market['id']
                    symbol = market['symbol']
                    self.markets[id] = market
                    self.markets[symbol] = market
                    self.symbols.append(symbol)
                
                self.symbols = sorted(self.symbols)
                self.ids = sorted(self.markets.keys())
            
            return markets
            
        except Exception as e:
            raise ExchangeError(f"获取市场数据失败: {e}")

    def parse_market(self, info):
        """解析市场信息 - 更健壮的版本"""
        try:
            # 安全获取 symbol
            if not isinstance(info, dict):
                return None
                
            symbol = self.safe_string(info, 'currency', '')
            if not symbol:
                return None
                
            symbol = symbol.upper().strip()
            
            # 确保符号格式正确 (如 EURUSD)
            if len(symbol) < 6:
                # 处理较短的符号
                base = symbol
                quote = 'USD'  # 默认报价货币
            else:
                base = symbol[:3]
                quote = symbol[3:]
                
            base = symbol[:3]
            quote = symbol[3:]
            
            # 安全处理精度
            digits = self.safe_integer(info, 'digits', 5)
            
            # 确保 digits 是整数
            if digits is not None:
                try:
                    digits = int(digits)
                except (ValueError, TypeError):
                    digits = 5
            
            market_id = symbol
            
            return {
                'id': market_id,
                'symbol': base + '/' + quote,
                'base': base,
                'quote': quote,
                'baseId': base,
                'quoteId': quote,
                'active': True,
                'type': 'spot',
                'spot': True,
                'margin': True,
                'precision': {
                    'price': digits,
                    'amount': 2,
                },
                'limits': {
                    'amount': {
                        'min': self.safe_number(info, 'minVolume', 0.01),
                        'max': self.safe_number(info, 'maxVolume'),
                    },
                    'price': {
                        'min': None,
                        'max': None,
                    },
                    'cost': {
                        'min': None,
                        'max': None,
                    },
                },
                'info': info,
            }
        except Exception as e:
            if self.verbose:
                print(f"解析市场信息失败: {e}, info: {info}")
            return None

    async def server_timezone(self):
        """获得mt5服务器时区"""
        if hasattr(self, 'timezone'):
            return self.timezone
        else:
            if not hasattr(self, 'token') or not self.token:
                await self.get_token()
                
            request = {
                'id': self.token,
            }
            response = await self.private_get_servertimezone(request)
            self.timezone = int(float(response))
            return self.timezone
    
    async def fetch_balance(self, params={}):
        """获取账户余额"""
        if not hasattr(self, 'token') or not self.token:
            await self.get_token()
            
        request = {
            'id': self.token,
        }
        response = await self.private_get_accountsummary(self.extend(request, params))
        return self.parse_balance(response)

    def parse_balance(self, response):
        """解析余额信息"""
        result = {
            'info': response,
            'timestamp': None,
            'datetime': None,
        }
        
        currency = 'USDT'
        balance = self.safe_number(response, 'balance', 0.0)
        margin = self.safe_number(response, 'margin', 0.0)
        free_margin = self.safe_number(response, 'freeMargin', 0.0)
        equity = self.safe_number(response, 'equity', 0.0)
        profit = self.safe_number(response, 'profit', 0.0) 
        
        result[currency] = {
            'free': free_margin,
            'used': margin,
            'total': balance,
            'equity': equity,
            'profit': profit,
        }
        
        return self.safe_balance(result)

    async def fetch_account_details(self, params={}):
        """获取账户信息"""
        if not hasattr(self, 'token') or not self.token:
            await self.get_token()
            
        request = {
            'id': self.token,
        }
        response = await self.private_get_accountdetails(self.extend(request, params))
        
        return self.parse_account(response)

    def parse_account(self, response):
        """解析账户信息"""
        return {
            'serverName': self.safe_string(response, 'serverName'),
            'user': self.safe_string(response, 'user'),
            'host': self.safe_string(response, 'host'),
            'port': self.safe_integer(response, 'port'),
            'serverTime': self.safe_string(response, 'serverTime'),
            'serverTimeZone': self.safe_integer(response, 'serverTimeZone'),
            'company': self.safe_string(response, 'company'),
            'currency': self.safe_string(response, 'currency', 'UST'),
            'accountName': self.safe_string(response, 'accountName'),
            'group': self.safe_string(response, 'group'),
            'accountType': self.safe_string(response, 'accountType'),
            'accountLeverage': self.safe_integer(response, 'accountLeverage'),
            'accountMethod': self.safe_string(response, 'accountMethod'),
            'isInvestor': self.safe_value(response, 'isInvestor', False),
        }

    async def fetch_ticker(self, symbol, params={}):
        """获取行情数据"""
        await self.load_markets()
        market = self.market(symbol)
        
        if not hasattr(self, 'token') or not self.token:
            await self.get_token()
            
        request = {
            'id': self.token,
            'symbol': market['id'],
        }
        
        response = await self.private_get_getquote(self.extend(request, params))
        return self.parse_ticker(response, market)

    def parse_ticker(self, ticker, market=None):
        """解析行情数据"""
        symbol = market['symbol'] if market else None
        timestamp = None
        if ticker.get('time'):
            try:
                timestamp = self.parse8601(ticker.get('time'))
            except:
                timestamp = None
        
        return {
            'symbol': symbol,
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp) if timestamp else None,
            'high': None,
            'low': None,
            'bid': self.safe_number(ticker, 'bid'),
            'bidVolume': None,
            'ask': self.safe_number(ticker, 'ask'),
            'askVolume': None,
            'vwap': None,
            'open': None,
            'close': None,
            'last': self.safe_number(ticker, 'last'),
            'previousClose': None,
            'change': None,
            'percentage': None,
            'average': None,
            'baseVolume': self.safe_number(ticker, 'volume'),
            'quoteVolume': None,
            'info': ticker,
        }

    async def fetch_tickers(self, symbols: Optional[List[str]] = None, params={}):
        """异步获取多个交易对的行情数据"""
        if not hasattr(self, 'token') or not self.token:
            await self.get_token()
        
        request = {
            'id': self.token,
        }
        
        # 如果指定了特定的交易对
        if symbols is not None:
            # 将符号列表转换为 MT5 格式
            mt5_symbols = []
            for symbol in symbols:
                market = self.market(symbol)
                mt5_symbols.append(market['id'])
            request['symbols'] = mt5_symbols
        
        try:
            response = await self.private_get_getquotemany(self.extend(request, params))
            return self.parse_tickers(response, symbols)
        except Exception as e:
            # 如果批量获取失败，回退到逐个获取
            if symbols is not None:
                return await self.fetch_tickers_fallback(symbols, params)
            else:
                raise ExchangeError(f"获取批量行情失败: {e}")

    async def fetch_tickers_fallback(self, symbols, params={}):
        """异步回退方法：逐个获取交易对行情"""
        tickers = {}
        for symbol in symbols:
            try:
                ticker = await self.fetch_ticker(symbol, params)
                tickers[symbol] = ticker
            except Exception as e:
                if self.verbose:
                    print(f"获取 {symbol} 行情失败: {e}")
                continue
        return tickers

    def parse_tickers(self, response, symbols=None):
        """解析批量行情数据（与同步版本相同）"""
        tickers = {}
        
        if isinstance(response, list):
            # 如果响应是数组
            for ticker_data in response:
                try:
                    ticker = self.parse_ticker(ticker_data)
                    if ticker and ticker.get('symbol'):
                        tickers[ticker['symbol']] = ticker
                except Exception as e:
                    if self.verbose:
                        print(f"解析行情数据失败: {e}")
                    continue
        elif isinstance(response, dict):
            # 如果响应是字典
            for symbol_key, ticker_data in response.items():
                try:
                    ticker = self.parse_ticker(ticker_data)
                    if ticker and ticker.get('symbol'):
                        tickers[ticker['symbol']] = ticker
                except Exception as e:
                    if self.verbose:
                        print(f"解析行情数据失败 {symbol_key}: {e}")
                    continue
        
        # 如果指定了特定的交易对，确保返回的顺序一致
        if symbols is not None:
            ordered_tickers = {}
            for symbol in symbols:
                if symbol in tickers:
                    ordered_tickers[symbol] = tickers[symbol]
            return ordered_tickers
        
        return tickers

    async def fetch_open_orders(self, symbol=None, since=None, limit=None, params={}):
        """异步获取未平仓订单 - 修复版本"""
        if not hasattr(self, 'token') or not self.token:
            await self.get_token()
            
        request = {
            'id': self.token,
        }
        
        response = await self.private_get_openedorders(self.extend(request, params))
        
        # 如果指定了特定交易对，进行过滤
        if symbol is not None:
            market = self.market(symbol)
            filtered_orders = []
            for order in response:
                if isinstance(order, dict) and order.get('symbol') == market['id']:
                    filtered_orders.append(order)
            return self.parse_orders(filtered_orders, market, since, limit)
        else:
            return self.parse_orders(response, None, since, limit)

    async def fetch_closed_orders(self, symbol=None, since=None, limit=None, params={}):
        """异步获取已平仓订单 - 修复版本"""
        if not hasattr(self, 'token') or not self.token:
            await self.get_token()
            
        request = {
            'id': self.token,
        }
        
        response = await self.private_get_closedorders(self.extend(request, params))
        
        # 如果指定了特定交易对，进行过滤
        if symbol is not None:
            market = self.market(symbol)
            filtered_orders = []
            for order in response:
                if isinstance(order, dict) and order.get('symbol') == market['id']:
                    filtered_orders.append(order)
            return self.parse_orders(filtered_orders, market, since, limit)
        else:
            return self.parse_orders(response, None, since, limit)

    def parse_order(self, order, market=None):
        """解析订单信息 - 修复市场符号问题"""
        try:
            id = self.safe_string(order, 'ticket')
            market_id = self.safe_string(order, 'symbol')
            
            # 安全地解析市场符号
            symbol = None
            if market is not None:
                symbol = market['symbol']
            elif market_id is not None:
                # 修复：提供更多参数来正确解析符号
                # 假设 MT5 的符号格式是 BASEQUOTE（如 EURUSD, BTCUSD）
                if len(market_id) >= 6:
                    # 尝试解析为 3+3 格式（如 EURUSD, GBPUSD）
                    base = market_id[:3]
                    quote = market_id[3:]
                    symbol = base + '/' + quote
                else:
                    # 如果无法解析，使用原始 market_id
                    symbol = market_id
            
            timestamp = self.parse8601(self.safe_string(order, 'openTime'))
            last_trade_timestamp = self.parse8601(self.safe_string(order, 'closeTime'))
            
            status = self.parse_order_status(self.safe_string(order, 'state'))
            side = self.parse_order_side(self.safe_string(order, 'orderType'))
            type = self.parse_order_type(self.safe_string(order, 'orderType'))
            
            price = self.safe_number(order, 'openPrice')
            amount = self.safe_number(order, 'lots')
            filled = self.safe_number(order, 'closeLots', 0)
            
            remaining = None
            if amount is not None and filled is not None:
                remaining = amount - filled
            
            cost = None
            if price is not None and filled is not None:
                cost = price * filled
            
            fee = None
            fee_cost = self.safe_number(order, 'commission', 0)
            if fee_cost != 0:
                fee = {
                    'cost': fee_cost,
                    'currency': None,
                }
            # 确保所有必需字段都有值
            if timestamp is None:
                timestamp = self.milliseconds()    
            
            return self.safe_order({
                'id': id,
                'clientOrderId': None,
                'datetime': self.iso8601(timestamp),
                'timestamp': timestamp,
                'lastTradeTimestamp': last_trade_timestamp,
                'lastUpdateTimestamp': last_trade_timestamp,
                'status': status,
                'symbol': symbol,
                'type': type,
                'timeInForce': None,
                'postOnly': None,
                'side': side,
                'price': price,
                'stopLossPrice': self.safe_number(order, 'stopLoss'),
                'takeProfitPrice': self.safe_number(order, 'takeProfit'),
                'reduceOnly':None,
                'triggerPrice': None,
                'amount': amount,
                'filled': filled,
                'remaining': remaining,
                'cost': cost,
                'trades': None,
                'fee': fee,
                'info': order,
                'average': None,
            })
        except Exception as e:
            if self.verbose:
                print(f"解析订单失败: {e}, order: {order}")
            return self.safe_order({
                'id': self.safe_string(order, 'ticket'),
                'symbol': symbol,
                'status': 'unknown',
                'side': 'unknown',
                'type': 'unknown',
                'timestamp': self.milliseconds(),
                'info': order,
            })

    def parse_order_status(self, status):
        statuses = {
            'Started': 'open',
            'Placed': 'open',
            'Cancelled': 'canceled',
            'Partial': 'open',
            'Filled': 'closed',
            'Rejected': 'rejected',
            'Expired': 'expired',
        }
        return self.safe_string(statuses, status, status)

    def parse_order_side(self, side):
        sides = {
            'Buy': 'buy',
            'Sell': 'sell',
            'BuyLimit': 'buy',
            'SellLimit': 'sell',
            'BuyStop': 'buy',
            'SellStop': 'sell',
        }
        return self.safe_string(sides, side, side)

    def parse_order_type(self, type):
        types = {
            'Buy': 'market',
            'Sell': 'market',
            'BuyLimit': 'limit',
            'SellLimit': 'limit',
            'BuyStop': 'stop',
            'SellStop': 'stop',
        }
        return self.safe_string(types, type, type)

    def parse_position(self, order_data, market: Market = None):
        """从订单数据解析持仓"""
        # 只有状态为 Filled 的订单才是持仓
        state = self.safe_string(order_data, 'state')
        if state != 'Filled':
            return None
            
        symbol = self.safe_string(order_data, 'symbol')
        if symbol and len(symbol) >= 6:
            base = symbol[:3]
            quote = symbol[3:]
            symbol = base + '/' + quote
        
        timestamp = self.parse8601(self.safe_string(order_data, 'openTime'))
        open_timestamp_utc = self.safe_integer(order_data, 'openTimestampUTC')
        if open_timestamp_utc:
            timestamp = open_timestamp_utc
        
        # 确定持仓方向
        order_type = self.safe_string(order_data, 'orderType')
        side = 'long' if order_type == 'Buy' else 'short'
        
        # 计算持仓价值
        contracts = self.safe_number(order_data, 'lots', 0)
        entry_price = self.safe_number(order_data, 'openPrice', 0)
        current_price = self.safe_number(order_data, 'closePrice', entry_price)
        notional = contracts * entry_price if contracts and entry_price else None
        
        # 计算盈亏百分比
        percentage = None
        if entry_price and current_price and entry_price != 0:
            if side == 'long':
                percentage = (current_price - entry_price) / entry_price
            else:
                percentage = (entry_price - current_price) / entry_price
        
        return {
            'id': self.safe_string(order_data, 'ticket'),
            'symbol': symbol,
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
            'side': side,
            'contracts': contracts,
            'contractSize': self.safe_number(order_data, 'contractSize', 1.0),
            'entryPrice': entry_price,
            'markPrice': current_price,  # 使用当前价格作为标记价格
            'notional': notional,
            'leverage': 1,  # MT5 可能需要从账户信息获取
            'unrealizedPnl': self.safe_number(order_data, 'profit', 0),
            'realizedPnl': 0,  # 对于持仓，已实现盈亏为0
            'liquidationPrice': None,  # MT5 可能不提供
            'marginMode': 'cross',
            'percentage': percentage,
            'marginRatio': None,
            'collateral': None,
            'initialMargin': None,  # 可能需要计算
            'initialMarginPercentage': None,
            'maintenanceMargin': None,
            'maintenanceMarginPercentage': None,
            # 'info': order_data,
        }
    
    async def create_order(self, symbol, type, side, amount, price=None, params={}):
        """创建订单"""
        await self.load_markets()
        market = self.market(symbol)
        
        if not hasattr(self, 'token') or not self.token:
            await self.get_token()
            
        request = {
            'id': self.token,
            'symbol': market['id'],
            'volume': amount,
        }
        
        # 映射订单类型
        operation_map = {
            'market': {
                'buy': 'Buy',
                'sell': 'Sell',
            },
            'limit': {
                'buy': 'BuyLimit',
                'sell': 'SellLimit',
            },
            'stop': {
                'buy': 'BuyStop',
                'sell': 'SellStop',
            },
        }
        
        if type in operation_map and side in operation_map[type]:
            request['operation'] = operation_map[type][side]
        else:
            raise InvalidOrder(self.id + ' createOrder does not support order type ' + type + ' and side ' + side)
        
        if type in ['limit', 'stop'] and price is not None:
            request['price'] = price
            
        # 处理止损止盈
        stop_loss = self.safe_number(params, 'stopLoss')
        take_profit = self.safe_number(params, 'takeProfit')
        if stop_loss is not None:
            request['stoploss'] = stop_loss
        if take_profit is not None:
            request['takeprofit'] = take_profit
            
        response = await self.private_get_ordersend(self.extend(request, params))
        return self.parse_order(response, market)

    async def cancel_order(self, id, symbol=None, params={}):
        """取消订单"""
        if not hasattr(self, 'token') or not self.token:
            await self.get_token()
            
        request = {
            'id': self.token,
            'ticket': int(id),
        }
        response = await self.private_get_orderclose(self.extend(request, params))
        return self.parse_order(response)

    async def private_get(self, endpoint, params={}):
        """发送私有 GET 请求"""
        return await self.fetch_private(endpoint, 'GET', params)

    async def fetch_private(self, path, method='GET', params={}, headers=None, body=None):
        """发送私有 API 请求"""
        base_url = self.implode_hostname(self.urls['api']['private'])
        url = base_url + '/' + path
        query = self.omit(params, self.extract_params(path))
        
        if method == 'GET' and query:
            url += '?' + self.urlencode(query)
        
        if self.verbose:
            print(f"🔧 发送请求: {url}")
        
        import aiohttp
        try:
            async with aiohttp.ClientSession() as session:
                async with session.get(url, timeout=aiohttp.ClientTimeout(total=30)) as response:
                    if response.status == 200:
                        content = await response.text()
                        return self.parse_json(content)
                    else:
                        error_text = await response.text()
                        raise ExchangeError(f"HTTP {response.status}: {error_text}")
        except asyncio.TimeoutError:
            raise ExchangeError("请求超时")
        except Exception as e:
            raise ExchangeError(f"请求失败: {e}")

    def parse_json(self, response):
        """解析响应，支持多种格式"""
        if not response:
            return response
        
        response = response.strip()
        
        # 处理常见的成功响应
        if response in ['OK', 'SUCCESS', 'True', 'true']:
            return True
        
        # 处理常见的失败响应
        if response in ['FAIL', 'ERROR', 'False', 'false']:
            return False
        
        # 尝试解析 JSON
        try:
            import json
            return json.loads(response)
        except json.JSONDecodeError:
            # 不是 JSON，返回原始响应
            return response
        except Exception as e:
            if self.verbose:
                print(f"响应解析失败: {e}, 响应: {response}")
            return response

    def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
        """签名请求"""
        base_url = self.implode_hostname(self.urls['api'][api])
        url = base_url + '/' + path
        query = self.omit(params, self.extract_params(path))
        
        if method == 'GET' and query:
            url += '?' + self.urlencode(query)
        
        # 调试信息
        if self.verbose:
            print(f"🔧 Debug: Final URL: {url}")
            print(f"🔧 Debug: Method: {method}")
            print(f"🔧 Debug: Params: {params}")
        
        return {
            'url': url,
            'method': method,
            'body': body,
            'headers': headers
        }