from decimal import Decimal as D

from core.exchanges import GenericAPIError
from core.models import Account, Strategy, Trade
from core.util import logs

log = logs.get_logger(__name__)


# def to_usd(account, amount, from_currency):
#     if account.exchange == "alpaca":
#         separator = "/"
#     elif account.exchange == "oanda":
#         separator = "_"
#     symbol = f"{from_currency.upper()}{separator}{to_currency.upper()}"
#     prices = account.client.get_currencies([symbol])


def get_pair(account, base, quote, invert=False):
    """
    Get the pair for the given account and currencies.
    :param account: Account object
    :param base: Base currency
    :param quote: Quote currency
    :param invert: Invert the pair
    :return: currency symbol, e.g. BTC_USD, BTC/USD, etc.
    """
    # Currently we only have two exchanges with different pair separators
    if account.exchange == "alpaca":
        separator = "/"
    elif account.exchange == "oanda":
        separator = "_"

    # Flip the pair if needed
    if invert:
        symbol = f"{quote.upper()}{separator}{base.upper()}"
    else:
        symbol = f"{base.upper()}{separator}{quote.upper()}"
    # Check it exists
    if symbol not in account.supported_symbols:
        return False
    return symbol


def to_currency(direction, account, amount, from_currency, to_currency):
    """
    Convert an amount from one currency to another.
    :param direction: Direction of the trade
    :param account: Account object
    :param amount: Amount to convert
    :param from_currency: Currency to convert from
    :param to_currency: Currency to convert to
    :return: Converted amount
    """
    # This is needed because OANDA has different values for bid and ask
    if direction == "buy":
        price_index = "bids"
    elif direction == "sell":
        price_index = "asks"
    symbol = get_pair(account, from_currency, to_currency)
    if not symbol:
        symbol = get_pair(account, from_currency, to_currency, invert=True)
        inverted = True

        # Bit of a hack but it works
        if not symbol:
            log.error(f"Could not find symbol for {from_currency} -> {to_currency}")
            raise Exception("Could not find symbol")
    try:
        prices = account.client.get_currencies([symbol])
    except GenericAPIError as e:
        log.error(f"Error getting currencies and inverted currencies: {e}")
        return None
    price = prices["prices"][0][price_index][0]["price"]

    # If we had to flip base and quote, we need to use the reciprocal of the price
    if inverted:
        price = D(1.0) / D(price)

    # Convert the amount to the destination currency
    converted = D(amount) * price

    return converted


def get_trade_size_in_base(direction, account, strategy, cash_balance, base):
    """
    Get the trade size in the base currency.
    :param direction: Direction of the trade
    :param account: Account object
    :param strategy: Strategy object
    :param cash_balance: Cash balance in the Account's base currency
    :param base: Base currency
    :return: Trade size in the base currency
    """

    # Convert the trade size in percent to a ratio
    trade_size_as_ratio = D(strategy.trade_size_percent) / D(100)
    log.debug(f"Trade size as ratio: {trade_size_as_ratio}")

    # Multiply with cash balance to get the trade size in the account's
    # base currency
    amount_fiat = D(trade_size_as_ratio) * D(cash_balance)
    log.debug(f"Trade size: {amount_fiat}")

    # Convert the trade size to the base currency
    if account.currency.lower() == base.lower():
        trade_size_in_base = amount_fiat
    else:
        trade_size_in_base = to_currency(
            direction, account, amount_fiat, account.currency, base
        )
    log.debug(f"Trade size in base: {trade_size_in_base}")

    return trade_size_in_base


def get_tp_sl(direction, strategy, price):
    """
    Get the take profit and stop loss prices.
    :param direction: Direction of the trade
    :param strategy: Strategy object
    :param price: Price of the trade
    :return: Take profit and stop loss prices
    """

    # Convert TP and SL to ratios
    stop_loss_as_ratio = D(strategy.stop_loss_percent) / D(100)
    take_profit_as_ratio = D(strategy.take_profit_percent) / D(100)
    log.debug(f"Stop loss as ratio: {stop_loss_as_ratio}")
    log.debug(f"Take profit as ratio: {take_profit_as_ratio}")

    # Calculate the TP and SL prices by multiplying with the price
    stop_loss_var = D(price) * D(stop_loss_as_ratio)
    take_profit_var = D(price) * D(take_profit_as_ratio)
    log.debug(f"Stop loss var: {stop_loss_var}")
    log.debug(f"Take profit var: {take_profit_var}")

    # Flip addition operators for inverse trade directions
    # * We need to subtract the SL for buys, since we are losing money if
    # the price goes down
    # * We need to add the TP for buys, since we are gaining money if
    # the price goes up
    # * We need to add the SL for sells, since we are losing money if
    # the price goes up
    # * We need to subtract the TP for sells, since we are gaining money if
    # the price goes down
    if direction == "buy":
        stop_loss = D(price) - D(stop_loss_var)
        take_profit = D(price) + D(take_profit_var)
    elif direction == "sell":
        stop_loss = D(price) + D(stop_loss_var)
        take_profit = D(price) - D(take_profit_var)
    log.debug(f"Stop loss: {stop_loss}")
    log.debug(f"Take profit: {take_profit}")

    return (stop_loss, take_profit)


def get_price_bound(direction, strategy, price):
    """
    Get the price bound for a given price using the slippage from the strategy.
    :param direction: Direction of the trade
    :param strategy: Strategy object
    :param price: Price of the trade
    :return: Price bound
    """

    # Convert the slippage to a ratio
    price_slippage_as_ratio = D(strategy.price_slippage_percent) / D(100)
    log.debug(f"Price slippage as ratio: {price_slippage_as_ratio}")

    # Calculate the price bound by multiplying with the price
    # The price bound is the worst price we are willing to pay for the trade
    price_slippage = D(price) * D(price_slippage_as_ratio)
    log.debug(f"Price slippage: {price_slippage}")

    # Subtract slippage for buys, since we lose money if the price goes down
    if direction == "buy":
        price_bound = D(price) - D(price_slippage)

    # Add slippage for sells, since we lose money if the price goes up
    elif direction == "sell":
        price_bound = D(price) + D(price_slippage)
    log.debug(f"Price bound: {price_bound}")
    return price_bound


def execute_strategy(callback, strategy):
    """
    Execute a strategy.
    :param callback: Callback object
    :param strategy: Strategy object
    """

    # Get the account's balance in the native account currency
    cash_balance = strategy.account.client.get_balance()
    log.debug(f"Cash balance: {cash_balance}")

    # Instruments supported by the account
    if not strategy.account.instruments:
        strategy.account.update_info()
        # Refresh account object
        strategy.account = Account.objects.get(id=strategy.account.id)

    instruments = strategy.account.instruments
    if not instruments:
        log.error("No instruments found")
        return

    # Shorten some hook, strategy and callback vars for convenience
    user = strategy.user
    account = strategy.account
    hook = callback.hook
    base = callback.base
    quote = callback.quote
    direction = hook.direction

    # Don't be silly
    if callback.exchange != account.exchange:
        log.error("Market exchange differs from account exchange.")
        return

    # Get the pair we are trading
    symbol = get_pair(account, base, quote)
    if not symbol:
        log.error(f"Symbol not supported by account: {symbol}")
        return

    # Extract the information for the symbol
    instrument = strategy.account.client.extract_instrument(instruments, symbol)
    if not instrument:
        log.error(f"Symbol not found: {symbol}")
        return

    # Get the required precision
    try:
        trade_precision = instrument["tradeUnitsPrecision"]
        display_precision = instrument["displayPrecision"]
    except KeyError:
        log.error(f"Precision not found for {symbol}")
        return

    # Round the received price to the display precision
    price = round(D(callback.price), display_precision)
    log.debug(f"Extracted price of quote: {price}")

    # 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"

    # Only using market orders for now, but with price bounds, so it's a similar
    # amount of protection from market fluctuations
    # type = "market"

    # For OANDA we can use the price since it should match exactly
    # Not yet sure how to use both limit and market orders
    type = "limit"

    # Convert the trade size, which is currently in the account's base currency,
    # to the base currency of the pair we are trading
    trade_size_in_base = get_trade_size_in_base(
        direction, account, strategy, cash_balance, base
    )

    # Calculate TP/SL
    stop_loss, take_profit = get_tp_sl(direction, strategy, price)

    # Calculate price bound and round to the display precision
    price_bound = round(get_price_bound(direction, strategy, price), display_precision)

    # Use the price reported by the callback for limit orders
    if type == "limit":
        price_for_trade = price

    # Use the price bound for market orders
    elif type == "market":
        price_for_trade = price_bound

    # Create object, note that the amount is rounded to the trade precision
    new_trade = Trade.objects.create(
        user=user,
        account=account,
        hook=hook,
        symbol=symbol,
        type=type,
        # amount_fiat=amount_fiat,
        amount=float(round(trade_size_in_base, trade_precision)),
        # price=price_bound,
        price=price_for_trade,
        stop_loss=float(round(stop_loss, display_precision)),
        take_profit=float(round(take_profit, display_precision)),
        direction=direction,
    )
    new_trade.save()
    info = new_trade.post()
    log.debug(f"Posted trade: {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.")
            continue
        execute_strategy(callback, strategy)