from jesse.strategies import Strategy, cached
import jesse.indicators as ta
from jesse import utils
from jesse.routes import router
from jesse.helpers import timeframe_to_one_minutes, timestamp_to_time


class MGStrategy(Strategy):

    def __init__(self):
        super().__init__()

        self.shared_vars['amount'] = 1000
        self.shared_vars['stop_loss'] = 0.01
        self.shared_vars['fisher_baseline'] = 0
        self.shared_vars['extra_candles_timeframe'] = router.extra_candles[0][2]
        self.shared_vars['timeframe'] = router.routes[0].timeframe

    # def hyperparameters(self):
    #   return [
    #      # {'name': 'fisher_baseline', 'type': int, 'min': 1, 'max': 4, 'default': 2},
    #     {'name': 'stop_loss', 'type': float, 'min': 0.01, 'max': 0.1, 'default': 0.02},
    # ]

    @property
    def extra_candle_closed(self) -> bool:
        current_time = self.current_candle[0]
        one_min_count = timeframe_to_one_minutes(
            self.shared_vars['extra_candles_timeframe']) / timeframe_to_one_minutes(self.shared_vars['timeframe'])
        timeframe_duration = one_min_count * 60_000
        if current_time % timeframe_duration == 0:
            return True
        return False

    @property
    @cached
    def fisher(self):
        candles = self.get_candles(self.exchange, self.symbol, self.shared_vars['extra_candles_timeframe'])[:-1]
        fisher, trigger = ta.fisher(candles, period=80, sequential=False)
        prev_fisher, prev_trigger = ta.fisher(candles[:-1], period=80, sequential=False)

        fisher_baseline_short = self.shared_vars['fisher_baseline']
        fisher_baseline_long = fisher_baseline_short * -1

        if fisher < fisher_baseline_long and trigger < fisher_baseline_long:
            if prev_fisher < prev_trigger:
                if fisher > trigger:
                    return 1

        elif fisher > fisher_baseline_short and trigger > fisher_baseline_short:
            if prev_fisher > prev_trigger:
                if fisher < trigger:
                    return -1

        return False

    @property
    def fisher_2h(self):
        candles = self.get_candles(self.exchange, self.symbol, '2h')
        fisher, trigger = ta.fisher(candles, period=5, sequential=False)
        if fisher > trigger:
            return 1
        else:
            return -1

    def should_long(self) -> bool:
        return False

    #    def should_short(self) -> bool:
    #         if self.extra_candle_closed:
    #            if self.fisher == -1:  # and self.fisher_1m == -1:
    #                print("short acılıyor...")
    #                return True
    #            return False

    def should_short(self) -> bool:
        if self.extra_candle_closed:
            if self.fisher == -1:
                if self.fisher_2h == -1:
                    return True
        return False

    def should_cancel(self) -> bool:
        return True

    def go_long(self):
        qty = utils.size_to_qty(self.shared_vars['amount'] * self.leverage, self.price, precision=5)
        self.buy = qty, self.price

        # self.stop_loss = qty, self.price - (self.price * 0.02)
        # self.take_profit = qty * 1, self.price + (self.price * 0.02)

    def go_short(self):
        qty = utils.size_to_qty(self.shared_vars['amount'] * self.leverage, self.price, precision=5)
        self.sell = qty, self.price
        self.stop_loss = qty, self.price + (self.price * self.shared_vars['stop_loss'])
        print(f"islem acareken fiyat: {self.price} tarih: {timestamp_to_time(self.time)}")
        # print("isleme girerken stop :", self.stop_loss)
        # print("---")
        # self.guncel_stop = (self.price + (self.price * 0.01))
        # print("en basta guncel stop :", self.guncel_stop)
        # print("en basta  yeni  stop :", self.yeni_stop)
        # self.take_profit = qty * 1, self.price - (self.price * 0.05)

    def sl_from_trailing_sl(self):
        stop_loss = self.average_stop_loss
        if self.is_short:
            if (self.position.pnl_percentage >= 1.5) & (self.position.pnl_percentage < 2):
                #                stop_loss = self.price + (self.price * 0.003)
                print("1-2", self.price, stop_loss)
            elif (self.position.pnl_percentage >= 2) & (self.position.pnl_percentage < 3):
                #                stop_loss = self.price + (self.price * 0.002)
                print("2-3", self.price, stop_loss)
            elif (self.position.pnl_percentage >= 3) & (self.position.pnl_percentage < 4):
                #                stop_loss = self.price + (self.price * 0.004)
                print("3-4", self.price, stop_loss)
            elif (self.position.pnl_percentage >= 5) & (self.position.pnl_percentage < 8):
                stop_loss = self.price + (self.price * 0.004)
                print("5-8", self.price, stop_loss)
            elif (self.position.pnl_percentage >= 8) & (self.position.pnl_percentage < 10):
                stop_loss = self.price + (self.price * 0.005)
                print("8-10", self.price, stop_loss)
            elif (self.position.pnl_percentage >= 10) & (self.position.pnl_percentage < 15):
                stop_loss = self.price + (self.price * 0.005)
                print("10-15", self.price, stop_loss)
            elif (self.position.pnl_percentage >= 15) & (self.position.pnl_percentage < 20):
                stop_loss = self.price + (self.price * 0.007)
                print("15-20", self.price, stop_loss)
            elif (self.position.pnl_percentage >= 20) & (self.position.pnl_percentage < 30):
                stop_loss = self.price + (self.price * 0.01)
                print("20-30", self.price, stop_loss)
            elif (self.position.pnl_percentage >= 30) & (self.position.pnl_percentage < 40):
                stop_loss = self.price + (self.price * 0.02)
                print("30-40", self.price, stop_loss)
            elif (self.position.pnl_percentage >= 40) & (self.position.pnl_percentage < 100):
                stop_loss = self.price + (self.price * 0.03)
                print("40-100", self.price, stop_loss)
            elif self.position.pnl_percentage >= 100:
                self.liquidate()

            if stop_loss >= self.average_stop_loss:
                return False

            return stop_loss

        # elif self.is_long:
        # print("ayni")

    def update_position(self):
        stop_loss = self.sl_from_trailing_sl()
        # print(f"Stop loss: {stop_loss}")
        if stop_loss:
            self.stop_loss = self.position.qty, stop_loss