# config.py
import os
from dotenv import load_dotenv

load_dotenv()  # 加载同目录下的 .env 文件

# 从环境变量中读取API密钥
API_KEY = os.getenv("OKX_API_KEY")
SECRET_KEY = os.getenv("OKX_SECRET_KEY")
PASSPHRASE = os.getenv("OKX_PASSPHRASE")  # 创建API时设置的密码

# 交易参数
SYMBOL = "BTC-USDT-SWAP"  # BTC永续合约
TIMEFRAME = "1H"          # 1小时K线

# okx_client.py
import hashlib
import hmac
import base64
import time
import requests
from config import API_KEY, SECRET_KEY, PASSPHRASE

class OKXClient:
    def __init__(self):
        self.base_url = "https://www.okx.com"
        self.api_key = API_KEY
        self.secret_key = SECRET_KEY.encode('utf-8')
        self.passphrase = PASSPHRASE

    def _sign(self, timestamp, method, request_path, body=""):
        """生成API请求签名"""
        message = str(timestamp) + method.upper() + request_path + body
        mac = hmac.new(self.secret_key, message.encode('utf-8'), hashlib.sha256)
        return base64.b64encode(mac.digest()).decode('utf-8')

    def _get_headers(self, request_path, method="GET", body=""):
        """生成请求头"""
        timestamp = str(time.time())[:13]  # OKX使用毫秒时间戳的前13位
        signature = self._sign(timestamp, method, request_path, body)
        return {
            "OK-ACCESS-KEY": self.api_key,
            "OK-ACCESS-SIGN": signature,
            "OK-ACCESS-TIMESTAMP": timestamp,
            "OK-ACCESS-PASSPHRASE": self.passphrase,
            "Content-Type": "application/json"
        }

    def get_kline_data(self, instId, bar="1H", limit=100):
        """获取K线数据"""
        request_path = f"/api/v5/market/candles?instId={instId}&bar={bar}&limit={limit}"
        url = self.base_url + request_path
        headers = self._get_headers(request_path)
        response = requests.get(url, headers=headers)
        return response.json()

    def place_order(self, instId, tdMode, side, ordType, sz, px=None):
        """下单"""
        request_path = "/api/v5/trade/order"
        url = self.base_url + request_path
        body = {
            "instId": instId,
            "tdMode": tdMode,  # 交易模式：isolated（逐仓）, cross（全仓）
            "side": side,      # buy（买）, sell（卖）
            "ordType": ordType, # market（市价）, limit（限价）
            "sz": sz           # 数量
        }
        if px and ordType == "limit":
            body["px"] = str(px)

        headers = self._get_headers(request_path, method="POST", body=str(body))
        response = requests.post(url, headers=headers, json=body)
        return response.json()

# 示例：获取账户余额（只读权限即可）
    def get_account_balance(self, ccy="USDT"):
        """获取单一币种余额"""
        request_path = f"/api/v5/account/balance?ccy={ccy}"
        url = self.base_url + request_path
        headers = self._get_headers(request_path)
        response = requests.get(url, headers=headers)
        return response.json()

# strategy.py
import pandas as pd
from okx_client import OKXClient

class SimpleMAStrategy:
    def __init__(self, client, symbol, timeframe):
        self.client = client
        self.symbol = symbol
        self.timeframe = timeframe
        self.fast_period = 10  # 快速均线周期
        self.slow_period = 30  # 慢速均线周期

    def fetch_and_prepare_data(self):
        """获取并处理K线数据"""
        data = self.client.get_kline_data(self.symbol, self.timeframe)
        if data['code'] != '0':
            print("获取K线数据失败:", data['msg'])
            return None

        # 将数据转换为Pandas DataFrame
        candles = data['data']
        df = pd.DataFrame(candles, columns=['timestamp', 'open', 'high', 'low', 'close', 'vol', 'volCcy', 'volCcyQuote', 'confirm'])
        df = df.iloc[::-1].reset_index(drop=True)  # 反转数据，使时间升序
        df[['open', 'high', 'low', 'close']] = df[['open', 'high', 'low', 'close']].astype(float)

        # 计算均线
        df['fast_ma'] = df['close'].rolling(window=self.fast_period).mean()
        df['slow_ma'] = df['close'].rolling(window=self.slow_period).mean()
        return df

    def generate_signal(self, df):
        """生成交易信号"""
        if df is None or len(df) < self.slow_period:
            return "HOLD", None

        latest = df.iloc[-1]
        prev = df.iloc[-2]

        # 金叉：快线上穿慢线，做多信号
        if prev['fast_ma'] <= prev['slow_ma'] and latest['fast_ma'] > latest['slow_ma']:
            return "BUY", latest['close']
        # 死叉：快线下穿慢线，做空信号
        elif prev['fast_ma'] >= prev['slow_ma'] and latest['fast_ma'] < latest['slow_ma']:
            return "SELL", latest['close']
        else:
            return "HOLD", None

    def execute_trade(self, signal, price):
        """执行交易（示例为市价单）"""
        if signal == "HOLD":
            print("无交易信号，继续监控...")
            return

        side = "buy" if signal == "BUY" else "sell"
        # 这里设定每次交易0.001个BTC（约合60美元，用于极小资金测试）
        size = "0.001"
        print(f"信号触发：{signal} | 触发价格：{price}")
        print(f"执行市价{side}单，数量：{size} {self.symbol}")

        # **!!! 模拟环境注释，实盘环境取消注释 !!!**
        # order_result = self.client.place_order(
        #     instId=self.symbol,
        #     tdMode="isolated",  # 使用逐仓模式，控制风险
        #     side=side,
        #     ordType="market",
        #     sz=size
        # )
        # print("订单结果:", order_result)

        # 模拟环境输出
        print(f"[模拟] 已提交市价{side}单，数量{size}。")
        print("--- 风险提示：此为模拟操作，实盘前请用模拟账户测试并设置止损 ---")

# main.py
import time
from strategy import SimpleMAStrategy
from okx_client import OKXClient

def main():
    print("=== OKX API 合约交易机器人启动 ===")
    client = OKXClient()
    strategy = SimpleMAStrategy(client, symbol="BTC-USDT-SWAP", timeframe="1H")

    # 先检查账户连接和余额（只读权限）
    balance_info = client.get_account_balance()
    print("账户连接状态:", balance_info)

    # 主循环，每5分钟检查一次
    check_interval = 300  # 秒
    while True:
        try:
            print(f"\n[{time.strftime('%Y-%m-%d %H:%M:%S')}] 开始策略分析...")
            df = strategy.fetch_and_prepare_data()
            signal, trigger_price = strategy.generate_signal(df)
            strategy.execute_trade(signal, trigger_price)

            print(f"下一次检查将在 {check_interval//60} 分钟后...")
            time.sleep(check_interval)

        except KeyboardInterrupt:
            print("\n程序被用户中断。")
            break
        except Exception as e:
            print(f"程序运行出错: {e}")
            time.sleep(60)  # 出错后等待1分钟再重试

if __name__ == "__main__":
    main()