import pandas as pd
import ccxt
import time
import pprint as pp
import threading
from multiprocessing import Process
from array import array

from datetime import datetime, timedelta
#usr_time = 12  # Time for candles
utc_time = str(datetime.utcnow().strftime("%y-%m-%d-%H-%M")).replace(' ', ''  )  # TODO Пофиксить!
exchange = ccxt.binance()


def get_time(hours):
    utc = datetime.utcnow()
    utc_past = utc - timedelta(hours=hours)
    #print(f'Current utc time: {utc}\nPrev 12h: {utc_past}')
    return {'Current': utc.strftime("%Y-%m-%d %H:%M:%S"), 'Past': utc_past.strftime("%Y-%m-%d %H:%M:%S")}



def get_ticker():
    symbol = str(input('Ticker: > ').upper())
    market = exchange.load_markets().keys()
    while symbol not in market:
        symbol = str(input(f'Can\'t find {symbol}. Try again: >').upper())
    return symbol


def collection(ticker):
    usr_time = int(input('How long do you want to receive the candles. \n'))
    from_timestamp = exchange.parse8601(get_time(usr_time)['Past'])
    t_frame = exchange.describe()['timeframes']
    period = 16
    while period not in t_frame:
        period = str(input('Candle timeframe: > '))
    ohlcv = exchange.fetch_ohlcv(ticker, period, since=from_timestamp)
    print(len(ohlcv))
    return ohlcv


def collection_auto(ticker, usr_time):
    from_timestamp = exchange.parse8601(get_time(usr_time)['Past'])
    period = '1m'
    ohlcv = exchange.fetch_ohlcv(ticker, period, since=from_timestamp)
    print(len(ohlcv))
    return ohlcv


def shaping(symbol, coll):
    # Vars
    part_symbol = symbol.split('/')
    # Make Pandas DataFrame
    df = pd.DataFrame.from_dict(coll).rename(index=int, columns={0: 'date', 1: 'open', 2: 'high', 3: 'low', 4: 'close', 5: 'vol'})
    pd.set_option('display.expand_frame_repr', False)
    pd.options.mode.chained_assignment = None  # Kill warning msg
    df['datetime'] = pd.to_datetime(df['date'], unit='ms')
    df = df.reindex_axis(['datetime', 'date', 'open', 'high', 'low', 'close', 'vol'], axis=1)
    df['price_change %'] = (df['close'].pct_change()) * 100
    df['vol_change %'] = (df['vol'].pct_change()) * 100
    # Make color
    df['color'] = ' '
    df['color'][df['close'] == df['open']] = 'Dodge'
    df['color'][df['close'] > df['open']] = 'Green'
    df['color'][df['close'] < df['open']] = 'Red'
    # Show tail
    print(df.tail())
    # Console output
    print(
      '-'*90,
      '\nVolume 12H: {} {}\n'
      'Mean volume 12H: {:.3f}\n'
      'Highest price 12H: {:.8f}'.format(df['vol'].sum(), part_symbol[0], df['vol'].mean(), df['high'].max())
    )
    # Create Excel file
    try:
        create_writer(df, part_symbol)
    except Exception as e:
        print(e)
    return 'Done'


def exchange_request(symbol):
    print('========proverka========')
    part_symbol = symbol.split('/')
    something =  binance.fetch_ticker(part_symbol)


def create_writer(df, part_symbol):
    # Create a Pandas Excel writer using XlsxWriter as the engine.
    writer = pd.ExcelWriter(f'{part_symbol[0]}-{exchange.name}-{utc_time}.xlsx', engine='xlsxwriter')
    workbook = writer.book
    sheet_name = part_symbol[0]
    df.to_excel(writer, sheet_name=sheet_name)
    worksheet = writer.sheets[sheet_name]
    worksheet.conditional_format('H1:H1048576',{'type': '3_color_scale'})
    colorize_candle(workbook, worksheet)
    writer.save()
    return 'Done'


def colorize_candle(workbook, worksheet):
    # Colors
    red = workbook.add_format({'bg_color': '#f97e6f'})
    green = workbook.add_format({'bg_color': '#7dc67d'})
    gray = workbook.add_format({'bg_color': '#D3D3D3'})
    # Colorize
    worksheet.conditional_format('K1:K1048576',{'type': 'text', 'criteria': 'containing', 'value':'Green' , 'format':green})
    worksheet.conditional_format('K1:K1048576',{'type': 'text', 'criteria': 'containing', 'value':'Red' , 'format':red})
    worksheet.conditional_format('K1:K1048576',{'type': 'text', 'criteria': 'containing', 'value':'Dodge' , 'format':gray})


def od_1():
    usr_time = 12
    ticker = 'ETH/BTC'
    data = collection_auto(ticker, usr_time)
    shaping(ticker, data)


def clearing(usr_input):
    market = exchange.load_markets()
    data = [ticker for ticker in usr_input if ticker in market]
    print(data)
    return(data)


def fetch_n_tuple(exchange):
    tickers = exchange.fetch_tickers()
    return [(k, float(v['info']['priceChangePercent'])) for k, v in tickers.items()]


def sorter(data, number):
    from operator import itemgetter
    s_data = sorted(data, key=itemgetter(1), reverse=True)
    return {'Winners': s_data[:number], 'Losers': s_data[-number:]}


# Start
def main():
    choice =  int(input('Выберите режим работы программы. 1 - ручной, 2 - автоматический. \n'
                        'В ручном режиме все задается пользователем, в автоматическом вводится только пара.\n'
                        'В автоматическом режиме тикеры всегда собираются по минуте. >\n '))
    if choice == 1:
        print('Выбран ручной режим.\n')
        ticker = get_ticker()
        data = collection(ticker)
        shaping(ticker, data)
    elif choise == 2:
        print('Выбран автоматический режим.\n')
        choice_two = int(input('1 - Собрать данные по паре за 12ч.\n'
                               '2 - Собирать данные по паре каждые 12ч, пока программа не остановится.\n'
                               '3 - Собрать данные за 12ч и начать выполнение 2-х одновременных задач.\n'
                               '4 - Выдать 12ч срез наиболее выросших/упаввших пар.\n'
                               '5 - Собрать сразу несколько пар.\n'))
        usr_time = 12
        if choice_two == 1:
                ticker = get_ticker()
                data = collection_auto(ticker,usr_time)
                shaping(ticker, data)
        elif choice_two == 2:
            otv = 1
            ticker = get_ticker()
            while(otv == 1):
                 data = collection_auto(ticker, usr_time)
                 shaping(ticker, data)
                 time.sleep(5)
        elif choice_two == 3:
                ticker = get_ticker()
                data = collection_auto(ticker, usr_time)
                shaping(ticker, data)
                time.sleep(5)
                p1 = Process(target = od_1())
                p1.start()
                p2 = Process(target = exchange_request(ticker))
                p2.start()
        elif choice_two == 4:
            data = fetch_n_tuple(exchange)  # Fetching
            pp.pprint(sorter(data, 10))  # Sorting
        elif choice_two == 5:
            ticker = input('Введите какие пары вы хотиие собрать:\n').upper().split()
            ticker = clearing(ticker)
            lean_str = int(len(ticker))
            for x in range(0, lean_str):
                data = collection_auto(ticker[x], usr_time)
                shaping(ticker[x], data)


#ETH/BTC
if __name__ == '__main__':
    main()