#!/usr/bin/env python

from argparse import ArgumentParser
from os import getenv
from dotenv import load_dotenv
from requests import get as requests_get
from requests import post as requests_post
from requests.auth import HTTPBasicAuth
from decimal import Decimal
from random import uniform
from pprint import pprint
from time import sleep
from db import Ticker, Balance, Order



satoshi = .00000001

class TradeOgre(object):
    def __init__(self):
        load_dotenv('.env')
        self.base = 'https://tradeogre.com/api/v1'
        self.auth = HTTPBasicAuth(
            getenv('TO_USER'),
            getenv('TO_PASS')
        )

    def req(self, route, method='get', data={}):
        url = self.base + route
        if method == 'get':
            r = requests_get(url, auth=self.auth)
        else:
            r = requests_post(url, auth=self.auth, data=data)
        return r.json()

    def get_trade_pair(self, pair):
        route = f'/ticker/{pair}'
        return self.req(route)

    def get_balance(self, currency):
        route = '/account/balance'
        data = {'currency': currency}
        return self.req(route, 'post', data)

    def get_balances(self):
        route = '/account/balances'
        return self.req(route)

    def submit_order(self, type, pair, quantity, price):
        route = f'/order/{type}'
        data = {'market': pair, 'quantity': quantity, 'price': price}
        return self.req(route, 'post', data)

    def get_order(self, uuid):
        route = f'/account/order/{uuid}'
        return self.req(route)


def get_metrics():
    # define vars
    to = TradeOgre()
    base = 'BTC'
    currency = 'WOW'
    trade_pair = f'{base}-{currency}'

    # get market data
    tp_res = to.get_trade_pair(trade_pair)
    print(tp_res)
    spreat_btc = Decimal(tp_res['ask']) - Decimal(tp_res['bid'])
    spread_sats = float(spreat_btc / Decimal(.00000001))
    spread_perc = (spreat_btc / Decimal(tp_res['ask'])) * 100

    # store market data in db
    t = Ticker(
        trade_pair=trade_pair,
        initial_price=tp_res['initialprice'],
        current_price=tp_res['price'],
        high_price=tp_res['high'],
        low_price=tp_res['low'],
        volume=tp_res['volume'],
        bid=tp_res['bid'],
        ask=tp_res['ask'],
        spread_btc=spreat_btc,
        spread_sats=spread_sats,
        spread_perc=spread_perc
    )
    t.save()

    # get balances and store in db
    for c in base, currency:
        gb_res = to.get_balance(c)
        print(gb_res)
        b = Balance(
            currency=c,
            total=gb_res['balance'],
            available=gb_res['available']
        )
        b.save()

def put_market_maker():
    to = TradeOgre()
    latest_ticker = Ticker.select().order_by(Ticker.date.desc()).get()
    if latest_ticker.spread_sats > 4:
        bid_amount = uniform(80, 90)
        ask_amount = uniform(80, 90)
        to_bid = latest_ticker.bid + satoshi
        to_ask = latest_ticker.ask - satoshi
        buy = to.submit_order('buy', 'BTC-WOW', bid_amount, '{:.8f}'.format(to_bid))
        print(buy)
        if buy['success']:
            o = Order(
                trade_pair='BTC-WOW',
                trade_type='market_maker',
                buy=True,
                quantity=bid_amount,
                price=to_bid,
                uuid=buy['uuid']
            )
            o.save()

            sleep(3)
            sell = to.submit_order('sell', 'BTC-WOW', ask_amount, '{:.8f}'.format(to_ask))
            print(sell)
            if sell['success']:
                o = Order(
                    trade_pair='BTC-WOW',
                    trade_type='market_maker',
                    buy=False,
                    quantity=ask_amount,
                    price=to_ask,
                    uuid=sell['uuid']
                )
                o.save()

def check_orders():
    to = TradeOgre()
    orders = Order.select().where(Order.active==True)
    for order in orders:
        print(order.uuid)
        o = to.get_order(order.uuid)
        print(o)
        if o['success'] is False:
            order.active = False
            order.save()
        sleep(5)


if __name__ == '__main__':
    parser = ArgumentParser(description='Helpful TradeOgre trading script')
    parser.add_argument('-t', '--trade', action='store_true', help='Put in buy/sell orders')
    parser.add_argument('-u', '--update-orders', action='store_true', help='Update status of orders')
    args = parser.parse_args()

    if args.trade:
        put_market_maker()
        exit()

    if args.update_orders:
        check_orders()
        exit()

    while True:
        get_metrics()
        sleep(60)