from alpaca.common.exceptions import APIError

from core.models import Strategy, Trade
from core.util import logs

log = logs.get_logger(__name__)


def get_balance(account):
    account_info = account.client.get_account()
    cash = account_info["equity"]
    try:
        return float(cash)
    except ValueError:
        return False


def get_market_value(account, symbol):
    try:
        position = account.client.get_position(symbol)
        return float(position["market_value"])
    except APIError:
        return False


def execute_strategy(callback, strategy):
    success, cash_balance = strategy.account.client.get_balance()
    log.debug(f"Cash balance: {cash_balance}")
    if not success:
        return None

    user = strategy.user
    account = strategy.account
    hook = callback.hook
    base = callback.base
    quote = callback.quote
    direction = hook.direction
    if quote not in ["usd", "usdt", "usdc", "busd"]:
        log.error(f"Quote not compatible with Dollar: {quote}")
        return False
    quote = "usd"  # TODO: MASSIVE HACK
    symbol = f"{base.upper()}/{quote.upper()}"

    if symbol not in account.supported_symbols:
        log.error(f"Symbol not supported by account: {symbol}")
        return False

    print(f"Identified pair from callback {symbol}")

    # market_from_alpaca = get_market_value(account, symbol)
    # change_percent = abs(((float(market_from_alpaca)-price)/price)*100)
    # if change_percent > strategy.price_slippage_percent:
    #     log.error(f"Price slippage too high: {change_percent}")
    #     return False

    # type = "limit"
    type = "market"
    trade_size_as_ratio = strategy.trade_size_percent / 100
    log.debug(f"Trade size as ratio: {trade_size_as_ratio}")
    amount_usd = trade_size_as_ratio * cash_balance
    log.debug(f"Trade size: {amount_usd}")
    price = callback.price
    if not price:
        return
    log.debug(f"Extracted price of quote: {price}")

    # We can do this because the quote IS in $ or equivalent
    trade_size_in_quote = amount_usd / price
    log.debug(f"Trade size in quote: {trade_size_in_quote}")

    # calculate sl/tp
    stop_loss_as_ratio = strategy.stop_loss_percent / 100
    take_profit_as_ratio = strategy.take_profit_percent / 100
    log.debug(f"Stop loss as ratio: {stop_loss_as_ratio}")
    log.debug(f"Take profit as ratio: {take_profit_as_ratio}")

    stop_loss_subtract = price * stop_loss_as_ratio
    take_profit_add = price * take_profit_as_ratio
    log.debug(f"Stop loss subtract: {stop_loss_subtract}")
    log.debug(f"Take profit add: {take_profit_add}")

    stop_loss = price - stop_loss_subtract
    take_profit = price + take_profit_add

    log.debug(f"Stop loss: {stop_loss}")
    log.debug(f"Take profit: {take_profit}")

    new_trade = Trade.objects.create(
        user=user,
        account=account,
        hook=hook,
        symbol=symbol,
        type=type,
        # amount_usd=amount_usd,
        amount=trade_size_in_quote,
        # price=price,
        stop_loss=stop_loss,
        take_profit=take_profit,
        direction=direction,
    )
    new_trade.save()
    posted, info = new_trade.post()
    log.debug(f"Posted trade: {posted} - {info}")


def process_callback(callback):
    log.info(f"Received callback for {callback.hook}")
    strategies = Strategy.objects.filter(hooks=callback.hook, enabled=True)
    log.debug(f"Matched strategies: {strategies}")
    for strategy in strategies:
        log.debug(f"Executing strategy {strategy}")
        if callback.hook.user != strategy.user:
            log.error("Ownership differs between callback and strategy.")
            return
        execute_strategy(callback, strategy)