from AlgorithmImports import *
from QuantConnect.DataSource import *
from QuantConnect.Data.UniverseSelection import *

class CoinAPIDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 6, 1)
        self.set_end_date(2021, 6, 1)
        self.set_cash(100000)
        self.universe_settings.asynchronous = True
        # Bitfinex accepts both Cash and Margin account types, select the one you need for the best reality modeling.
        self.set_brokerage_model(BrokerageName.BITFINEX, AccountType.MARGIN)

        # Warm up the security with the last known price to avoid conversion error
        self.set_security_initializer(lambda security: security.set_market_price(self.get_last_known_price(security)))
        
        # Requesting data, we only trade on BTCUSD in Bitfinex exchange
        crypto = self.add_crypto("BTCUSD", Resolution.MINUTE, Market.BITFINEX)
        self.btcusd = crypto.symbol
        self.minimum_order_size = crypto.symbol_properties.minimum_order_size
        
        # Historical data
        history = self.history(self.btcusd, 30, Resolution.DAILY)
        self.debug(f"We got {len(history)} items from our history request")

       # Add Crypto Universe Selection that select crypto pairs in Bitfinex exchange
        self._universe = self.add_universe(CryptoUniverse.bitfinex(self.universe_selection_filter))

        # Historical Universe data
        universe_history = self.history(self._universe, 30, Resolution.DAILY)
        self.debug(f"We got {len(universe_history)} items from our universe history request")
        for (univere_symbool, time), universe_day in universe_history.items():
            for universe_item in universe_day:
                self.debug(f"{universe_item.symbol} price at {universe_item.end_time}: {universe_item.close}")

    def universe_selection_filter(self, universe_day):
        # Filter for materially traded crypto pairs with significant size and dollar volume, assuming higher capital flow in for higher return
        return [universe_item.symbol for universe_item in universe_day
                if universe_item.volume >= 100 
                and universe_item.volume_in_usd > 10000]

    def on_data(self, slice: Slice) -> None:
        # Speculate-invest all available free cash on BTCUSD, obeying the order quantity restriction to avoid invalid order
        if self.portfolio.cash_book['BTC'].amount == 0:
            free_cash = self.portfolio.cash_book['USD'].amount * (1-self.settings.free_portfolio_value_percentage)
            quantity = free_cash / slice[self.btcusd].price
            quantity -= quantity % self.minimum_order_size
            if quantity > 0:
                self.market_order(self.btcusd, quantity)