from pydmm_connectors import BaseConnector, BaseFetcher, make_client_formed, make_fetcher_formed
from pydmm_connectors.core.logger import MarketLogger
from pydmm_connectors.models import Client, Symbol
from pydmm_strategy.market_making.config import MarketMakingInstanceConfig
from pydmm_strategy.price_targeting.config import PriceTargetingInstanceConfig
from pydmm_strategy.price_targeting.engine.context import PriceContext
from pydmm_strategy.price_targeting.sources import *
from pydmm_strategy.price_targeting.price_writer import PriceWriter
from pydmm_strategy.utility.price_oracle import BinanceWebSocketOracle
from pydmm_strategy.utility.kline_manager import BinanceKLineManager
import time

class PriceTargeting:

    def _target_client(self) -> float:
        if not isinstance(self._target_market, BaseConnector):
            raise RuntimeError
        book = self._target_market.get_best_book()
        return (book.ask_price + book.bid_price) / 2

    def _target_fetcher(self) -> float:
        if not isinstance(self._target_market, BaseFetcher):
            raise RuntimeError
        return self._target_market.get_price()

    def _target_none(self) -> float:
        # When target_market is None, return a default price
        # This shouldn't normally happen in real usage
        return 1.0

    def __init__(self, config: PriceTargetingInstanceConfig):
        self._logger = MarketLogger(config.path_to_log)

        if config.target_market is None:
            self._target_market = None
            self._target_base = self._target_none
        elif isinstance(config.target_market, Client):
            self._target_market = make_client_formed(config.target_market)
            self._target_base = self._target_client
        else:
            self._target_market = make_fetcher_formed(config.target_market)
            self._target_base = self._target_fetcher

        if config.target_price > 0.0:
            self._price_source = ConstPriceSource(config.target_price, self._logger)
        elif config.followed_asset in ['BTC', 'ETH', 'SOL']:
            followed_symbol = Symbol.from_full_name(config.followed_asset)
            oracle = BinanceWebSocketOracle([followed_symbol])
            self._price_source = OracleSource(followed_symbol, oracle, config.following_rate, self._logger)
        else:
            mid_source = MarketMidSource(config.is_internal, config.offset_from_target, self._logger)
            if config.use_trades:
                mock_mm_cfg = MarketMakingInstanceConfig(group = config.group, clients = [])
                trades_source = TradesSource(config.fill_percent_amt, config.group_clients, mock_mm_cfg.path_to_config, self._logger)
                if config.is_internal:
                    self._price_source = trades_source
                elif config.half_detach:
                    self._price_source = MinMultiSource([trades_source, mid_source])
                else:
                    self._price_source = mid_source
            else:
                self._price_source = mid_source

        self._cooldown = config.cooldown
        self._price_writer = PriceWriter(config.group, self._logger)
        self._target_volatility = config.target_volatility
        self._vol_manager = BinanceKLineManager(False, self._logger)

    def graceful_stop(self):
        return

    def run_event_loop(self):
        prev_price = self._target_base()
        self._price_source.initialize(prev_price)
        while True:
            cur_t = int(time.time() * 1000)
            self._logger.info('iter time:', cur_t)
            try:
                base_price = self._target_base()
                ctx = PriceContext(base_price, prev_price, cur_t)
                price = self._price_source.next(ctx)
                prev_price = price
                vol_norm_price = self._vol_manager.fetch().norm_price
                self._logger.info(f'price={price}, with vol: {price * (1 + vol_norm_price * self._target_volatility / 100)}')
                self._price_writer.log('price', {'price': price * (1 + vol_norm_price * self._target_volatility / 100)})
            except Exception as e:
                self._logger.error(f'pt exception: {e}')
            finally:
                time.sleep(self._cooldown)