import ccxt
from tabulate import tabulate
import pandas as pd
import datetime
import time
import sys
import os
import numpy as np

#Function to help calculating days until expiry — currently unused
def hours_between(d1, d2):
    d1 = datetime.datetime.strptime(d1, "%Y-%m-%d")
    d2 = datetime.datetime.strptime(d2, "%Y-%m-%d")
    return abs((d2 - d1).hours)

ftx = ccxt.ftx({
	'enableRateLimit': True,
	'apiKey':'4g7RKt0ZgG1lsga0E57EdG7X5wlWOsdEc3wiJ6B1',
	'secret':'shbBCtB-MJC5MIjwgd0lepRhEAPYa_8VKK09vtPN',
	})

#Collateral amount for optional total PnL columns
collateral = 10000.00
#print ('Collateral: $' + str(collateral))

def calc_futures():
	#Gets list of dictionaries; each list item is a dictionary of outputs for each future
	all_futures = ftx.publicGetFutures()
	all_futures = all_futures['result']

	#print ('Number of futures live: ' + str(len(all_futures)))

	#Separate perpetuals and calendar futures 
	perp_futures_all = []
	cal_futures_all = []

	for i in all_futures:
		if i['perpetual'] == True: 
			perp_futures_all.append(i)
		#Filter out MOVE contracts
		elif i['perpetual'] == False and 'MOVE' not in i['name']:
			cal_futures_all.append(i)

	#Cut down dictionaries into data only necessary for futures
	perp_futures = []
	cal_futures = []

	#For perps
	for i in perp_futures_all:
		i = {key:val for key, val in i.items()
		if key == 'last'
		or key == 'perpetual'
		or key == 'underlying'
		or key == 'name'
		or key == 'bid'
		or key == 'ask'
		}

		perp_futures.append(i)

	#For calendar expiration futures - some additional variables like Expiry needed
	for i in cal_futures_all:
		i = {key:val for key, val in i.items()
		if key == 'last'
		or key == 'perpetual'
		or key == 'underlying'
		or key == 'name'
		or key == 'expiry'
		or key == 'bid'
		or key == 'ask'
		}

		cal_futures.append(i)

	#Get funding rates, make into a list, for perps
	for i in perp_futures:
		#Get funding name + use it to pull funding stats
		future_name = i['name']
		funding = ftx.publicGetFuturesFutureNameStats ({'future_name': future_name})

		i["next_funding_rate"] = f'{funding["result"]["nextFundingRate"]:.8f}'
		i["next_funding_time"] = funding["result"]["nextFundingTime"]

	#Pandas-ize it
	perp_df = pd.DataFrame(perp_futures)
	cal_df = pd.DataFrame(cal_futures)

	#Rename cal columns
	#cal_df = cal_df.rename(columns{'last': 'cal_last', })

	#Set indexes
	perp_df.set_index('name')
	cal_df.set_index('name')

	#Merge calendar expiry and perp futures
	combined_df = perp_df.merge(cal_df, left_on='underlying', right_on='underlying')

	#Get price difference
	combined_df['price_dif'] = combined_df.last_y - combined_df.last_x
	combined_df['price_dif_%'] = combined_df.last_y / combined_df.last_x

	#Get $ needed of collateral per $ profit on futures spread trade
	combined_df['collateral_spread_trade'] = (combined_df.last_x + combined_df.last_y) / (abs(combined_df.price_dif))

	#Funding TODO

	#Find time left until expiry of calendar contract + estimate funding expenses between now and expiration?
	#print (ftx.parse8601(combined_df.expiry))
	#combined_df['time_remaining'] = hours_between(str(combined_df.next_funding_time), str(combined_df.expiry))

	#Lazy funding estimates
	#combined_df['funding_paid'] = (combined_df.last_x *(combined_df.next_funding_rate))

	#Total PnL
	combined_df['TotalPnL'] = collateral / combined_df.collateral_spread_trade

	#PnL % from collateral
	combined_df['PnL%'] = combined_df.TotalPnL / collateral
	combined_df['PnL%'] = (combined_df['PnL%'] * 100).astype(str) + '%'

	#Create market buy/sell spread PnL: PnL as if buying market one side and selling market another side
	#First create new column for if perp greater than cal or not
	combined_df.loc[combined_df['bid_x'] <=	combined_df['bid_y'], 'perp_greater'] = False
	combined_df.loc[combined_df['bid_x'] >= combined_df['bid_y'], 'perp_greater'] = True

	#Get price dif per market buys
	combined_df.loc[combined_df['perp_greater'] == True, 'market_price_dif'] = abs(combined_df['bid_x'] - combined_df['ask_y'])
	combined_df.loc[combined_df['perp_greater'] == False, 'market_price_dif'] = abs(combined_df['ask_x'] - combined_df['bid_y'])

	#Get $ needed of collateral per $ profit on market futures spread trade
	combined_df.loc[combined_df['perp_greater'] == True, 'collateral_spread_market'] = (combined_df.bid_x + combined_df.ask_y) / (abs(combined_df.market_price_dif))
	combined_df.loc[combined_df['perp_greater'] == False, 'collateral_spread_market'] = (combined_df.ask_x + combined_df.bid_y) / (abs(combined_df.market_price_dif))

	#Total market PnL
	combined_df['TotalPnLMarket'] = collateral / combined_df.collateral_spread_market

	#Market PnL % from collateral
	combined_df['MarketPnL%'] = combined_df.TotalPnLMarket / collateral
	combined_df['MarketPnL%'] = (combined_df['MarketPnL%'] * 100).astype(str) + '%'

	#Sorting
	combined_df = combined_df.sort_values(by=['collateral_spread_market'], ascending=True)

	#Make new dataframes with less columns of only important info
	combined_df_pretty = combined_df.loc[:, ['name_x', 'bid_x', 'ask_x', 'last_x', 'name_y', 'bid_y', 'ask_y', 'last_y', 'underlying', 'next_funding_rate', 'collateral_spread_trade', 'TotalPnL', 'PnL%', 'perp_greater', 'market_price_dif']]
	combined_df_market = combined_df.loc[:, ['name_x', 'bid_x', 'ask_x', 'name_y', 'bid_y', 'ask_y', 'underlying', 'next_funding_rate', 'market_price_dif', 'collateral_spread_market', 'TotalPnLMarket', 'MarketPnL%']]
	simple_df_market = combined_df.loc[:, ['name_x', 'bid_x', 'ask_x', 'name_y', 'bid_y', 'ask_y', 'underlying', 'next_funding_rate', 'MarketPnL%']]

	#Clear last readout and print new one
	os.system('cls' if os.name == 'nt' else "printf '\033c'")
	#print(tabulate(combined_df, headers='keys', tablefmt='pretty', stralign='left', numalign='right', floatfmt='.8f'))
	#print(tabulate(combined_df_market, headers='keys', tablefmt='pretty', stralign='left', numalign='right', floatfmt='.8f'))
	print(tabulate(simple_df_market, headers='keys', tablefmt='pretty', stralign='left', numalign='right', floatfmt='.8f'))

#Loop to refresh every 30 seconds
while True:
	calc_futures()
	time.sleep(30)