#import okx.Account as Account
import okx
import config_demo as config
from okx import Account, Trade, exceptions, MarketData


# Ваши API ключи
apikey = config.api_key
secretkey = config.secret_key
passphrase = config.passphrase

rehedge_dist = 27

delta_long_call =0
gamma_long_call = 0
delta_long_put =0
gamma_long_put = 0
delta_futures=0
minimum_vol = 0.037

long_volume = 0
short_volume = 0

total_delta = 0
total_gamma = 0
last_ask = 0
last_bid = 0

is_simulated = '1' # Production trading:0 , demo trading:1

accountAPI = Account.AccountAPI(apikey, secretkey, passphrase, False, is_simulated)

####################################################################
def get_prices():
    publicDataAPI = MarketData.MarketAPI(flag=is_simulated)
    result = publicDataAPI.get_ticker(instId='ETH-USD-SWAP')
    response = result['data'][0]
    bid_price = float(response['bidPx'])
    ask_price = float(response['askPx'])
    return ask_price, bid_price

# Get positions information
result = accountAPI.get_positions()
#print(result)
if result['code'] == '0': # Проверяем, что запрос успешен
    positions_data = result['data']
    print("Информация о позициях в отформатированном виде:")
    print("-" * 30)

    if positions_data: # Проверяем, что есть данные о позициях
        for position in positions_data:
            '''
            print(f"Инструмент: {position.get('instId', 'N/A')}")
            print(f"Тип инструмента: {position.get('instType', '')}")
            print(f"Позиция (количество контрактов): {position.get('pos', 'N/A')}")
            print(f"Средняя цена открытия: {position.get('avgPx', 'N/A')}")
            print(f"Направление позиции (long/short): {position.get('posSide', 'N/A')}")
            print(f"Ликвидационная цена: {position.get('liqPx', 'N/A')}")
            print(f"Маржа: {position.get('margin', 'N/A')}")
            print(f"Дельта: {position.get('deltaBS', 'N/A')}")
            print(f"Гамма: {position.get('gammaBS', 'N/A')}")'''
            print(f"Тип инструмента: {position.get('instType', '')}")
            if(position.get('instType', '') == 'OPTION' and float(position.get('gammaBS', 'N/A'))>0):
                print('gamma=',position.get('gammaBS', 'N/A'))
                print('delta = ',position.get('deltaBS', 'N/A'))
                total_delta +=float(position.get('deltaBS', 'N/A'))
                total_gamma +=float(position.get('gammaBS', 'N/A'))
            
            if(position.get('instType', '') == 'SWAP'):
                print('delta_futures= ',position.get('pos', 'N/A'))
                position_futures = float(position.get('pos', 'N/A'))
                last_ask,last_bid = get_prices()
                delta_futures = (10/last_ask)*position_futures
            '''
            pos_side = position.get('posSide', 'N/A')
            position_size = float(position.get('pos', 'N/A'))/10#минимальный лот 0,1 для фьючерсов,опционов
            delta = 0 # По умолчанию 0, если не удалось определить направление
            if position_size > 0:
                delta = position_size
            elif position_size < 0:
                delta = position_size
            print(f"Дельта позиции (упрощенно для фьючерсов/свопов): {delta}") # Упрощенное представление дельты
            '''
            print("-" * 20)
    else:
        print("Нет открытых позиций.")

    print("-" * 30)

else:
    print(f"Ошибка при получении позиций:")
    print(f"Код ошибки: {result['code']}")
    print(f"Сообщение: {result['msg']}")

print('total delta = ',total_delta)
print('total gamma = ',total_gamma)
delta_rehedge= total_gamma*rehedge_dist
print('delta_rehedge = ',delta_rehedge)

if total_delta>0 and delta_futures<=0:
    dof = total_delta - abs(delta_futures)
    print('dof=',dof)
    if dof>0:
        vol_short = delta_rehedge + dof
        vol_long = max(delta_rehedge - dof,minimum_vol)

    if dof<0:
        vol_short = max(delta_rehedge - abs(dof),minimum_vol)
        vol_long = delta_rehedge + abs(dof)

if total_delta<0 and delta_futures>=0:
    dof = abs(total_delta) - delta_futures
    if dof>0:
        vol_short = max(delta_rehedge - dof,minimum_vol)
        vol_long = delta_rehedge + dof

    if dof<0:
        vol_short = delta_rehedge + abs(dof)
        vol_long = max(delta_rehedge - abs(dof),minimum_vol)


print('vol_long = ',vol_long)
print('vol_short = ',vol_short) Модернизируй код, пусть результат получается через функцию