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, Fetcher, 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 __init__(self, config: PriceTargetingInstanceConfig):
        self._logger = MarketLogger(config.path_to_log)

        # Try to determine the type based on structure
        target_market = config.target_market
        if hasattr(target_market, 'ticker'):  # It's a Client
            self._target_market = make_client_formed(target_market)
            self._target_base = self._target_client
        elif hasattr(target_market, 'exchange'):  # It's a Fetcher
            self._target_market = make_fetcher_formed(target_market)
            self._target_base = self._target_fetcher
        else:
            # Try to create Fetcher from dict
            try:
                if isinstance(target_market, dict) and 'exchange' in target_market:
                    fetcher = Fetcher(**target_market)
                    self._target_market = make_fetcher_formed(fetcher)
                    self._target_base = self._target_fetcher
                else:
                    self._logger.error(f"ERROR: Cannot determine target_market type: {target_market}")
                    self._target_base = lambda: 0.0
            except Exception as e:
                self._logger.error(f"ERROR: Failed to create Fetcher from target_market: {e}")
                self._target_base = lambda: 0.0

        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(base=config.followed_asset, quote='USDT')
            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)