# Zeus Strategy: First Generation of GodStra Strategy with maximum
# AVG/MID profit in USDT
# Author: @Mablue (Masoud Azizi)
# github: https://github.com/mablue/
# IMPORTANT: INSTALL TA BEFOUR RUN(pip install ta)
# freqtrade hyperopt --hyperopt-loss SharpeHyperOptLoss --spaces buy sell roi --strategy Zeus
# --- Do not remove these libs ---
from datetime import timedelta, datetime
from typing import Optional

from freqtrade import data
from freqtrade.persistence import Trade
from freqtrade.strategy.parameters import CategoricalParameter, DecimalParameter, IntParameter, BooleanParameter

from numpy.lib import math
from freqtrade.strategy.interface import IStrategy
import pandas
from pandas import DataFrame
import time
import logging
import calendar
from freqtrade.loggers import setup_logging
from freqtrade.strategy.strategy_helper import merge_informative_pair

# --------------------------------

# Add your lib to import here
import ta
from functools import reduce
import numpy as np
import talib.abstract as talib
from freqtrade.strategy.strategy_helper import merge_informative_pair
import freqtrade.vendor.qtpylib.indicators as qtpylib

from random import shuffle

logger = logging.getLogger(__name__)

operators = [
    "D",  # Disabled gene
    ">",  # Indicator, bigger than cross indicator
    "<",  # Indicator, smaller than cross indicator
    "=",  # Indicator, equal with cross indicator
    "C",  # Indicator, crossed the cross indicator
    "CA",  # Indicator, crossed above the cross indicator
    "CB",  # Indicator, crossed below the cross indicator
    ">R",  # Normalized indicator, bigger than real number
    "=R",  # Normalized indicator, equal with real number
    "<R",  # Normalized indicator, smaller than real number
    "/>R",  # Normalized indicator devided to cross indicator, bigger than real number
    "/=R",  # Normalized indicator devided to cross indicator, equal with real number
    "/<R",  # Normalized indicator devided to cross indicator, smaller than real number
    "UT",  # Indicator, is in UpTrend status
    "DT",  # Indicator, is in DownTrend status
    "OT",  # Indicator, is in Off trend status(RANGE)
    "CUT",  # Indicator, Entered to UpTrend status
    "CDT",  # Indicator, Entered to DownTrend status
    "COT"  # Indicator, Entered to Off trend status(RANGE)
]
# number of candles to check up,don,off trend.
TREND_CHECK_CANDLES = 8
DECIMALS = 2

buy_crossed_indicator0 = 'MINUS_DM-5'
buy_operator0 = "/<R"
buy_indicator0 = 'MA-20'

buy_crossed_indicator1 = 'DX-5'
buy_operator1 = ">"
buy_indicator1 = 'STOCH-1-10'

buy_crossed_indicator2 = 'LINEARREG-50'
buy_operator2 = "/<R"
buy_indicator2 = 'CDLDRAGONFLYDOJI-5'

from tabulate import tabulate


def pprint_df(dframe):
    print(tabulate(dframe, headers='keys', tablefmt='psql', showindex=False))


def normalize(df):
    df = (df - df.min()) / (df.max() - df.min())
    return df


def gene_calculator(dataframe, indicator):
    # Cuz Timeperiods not effect calculating CDL patterns recognations
    if 'CDL' in indicator:
        splited_indicator = indicator.split('-')
        splited_indicator[1] = "0"
        new_indicator = "-".join(splited_indicator)
        # print(indicator, new_indicator)
        indicator = new_indicator

    gene = indicator.split("-")
    gene_name = gene[0]
    gene_len = len(gene)

    if indicator in dataframe.keys():
        # print(f"{indicator}, calculated befoure")
        # print(len(dataframe.keys()))
        return dataframe[indicator]
    else:
        result = None
        # For Pattern Recognations
        if gene_len == 1:
            # print('gene_len == 1\t', indicator)
            result = getattr(talib, gene_name)(
                dataframe
            )
            return normalize(result)
        elif gene_len == 2:
            # print('gene_len == 2\t', indicator)
            gene_timeperiod = int(gene[1])
            result = getattr(talib, gene_name)(
                dataframe,
                timeperiod=gene_timeperiod,
            )
            return normalize(result)
        # For
        elif gene_len == 3:
            # print('gene_len == 3\t', indicator)
            gene_timeperiod = int(gene[2])
            gene_index = int(gene[1])
            result = getattr(talib, gene_name)(
                dataframe,
                timeperiod=gene_timeperiod,
            ).iloc[:, gene_index]
            return normalize(result)
        # For trend operators(MA-5-SMA-4)
        elif gene_len == 4:
            # print('gene_len == 4\t', indicator)
            gene_timeperiod = int(gene[1])
            sharp_indicator = f'{gene_name}-{gene_timeperiod}'
            dataframe[sharp_indicator] = getattr(talib, gene_name)(
                dataframe,
                timeperiod=gene_timeperiod,
            )
            return normalize(talib.SMA(dataframe[sharp_indicator].fillna(0), TREND_CHECK_CANDLES))
        # For trend operators(STOCH-0-4-SMA-4)
        elif gene_len == 5:
            # print('gene_len == 5\t', indicator)
            gene_timeperiod = int(gene[2])
            gene_index = int(gene[1])
            sharp_indicator = f'{gene_name}-{gene_index}-{gene_timeperiod}'
            dataframe[sharp_indicator] = getattr(talib, gene_name)(
                dataframe,
                timeperiod=gene_timeperiod,
            ).iloc[:, gene_index]
            return normalize(talib.SMA(dataframe[sharp_indicator].fillna(0), TREND_CHECK_CANDLES))


def condition_generator(dataframe, operator, indicator, crossed_indicator, real_num, decalage):
    condition = (dataframe['volume'] > 10)

    # TODO : it ill callculated in populate indicators.

    dataframe[indicator] = gene_calculator(dataframe, indicator)
    dataframe[crossed_indicator] = gene_calculator(dataframe, crossed_indicator)

    indicator_trend_sma = f"{indicator}-SMA-{TREND_CHECK_CANDLES}"
    if operator in ["UT", "DT", "OT", "CUT", "CDT", "COT"]:
        dataframe[indicator_trend_sma] = gene_calculator(dataframe, indicator_trend_sma)

    if operator == ">":
        condition = (dataframe[indicator].shift(decalage) > dataframe[crossed_indicator].shift(decalage))
    elif operator == "=":
        condition = (np.isclose(dataframe[indicator].shift(decalage), dataframe[crossed_indicator].shift(decalage)))
    elif operator == "<":
        condition = (dataframe[indicator].shift(decalage) < dataframe[crossed_indicator].shift(decalage))
    elif operator == "C":
        condition = (
                (qtpylib.crossed_below(dataframe[indicator].shift(decalage),
                                       dataframe[crossed_indicator].shift(decalage))) |
                (qtpylib.crossed_above(dataframe[indicator].shift(decalage),
                                       dataframe[crossed_indicator].shift(decalage)))
        )
    elif operator == "CA":
        condition = (
            qtpylib.crossed_above(dataframe[indicator].shift(decalage), dataframe[crossed_indicator].shift(decalage)))
    elif operator == "CB":
        condition = (
            qtpylib.crossed_below(dataframe[indicator].shift(decalage), dataframe[crossed_indicator].shift(decalage)))
    elif operator == ">R":
        condition = (dataframe[indicator].shift(decalage) > real_num)
    elif operator == "=R":
        condition = (np.isclose(dataframe[indicator].shift(decalage), real_num))
    elif operator == "<R":
        condition = (dataframe[indicator].shift(decalage) < real_num)
    elif operator == "/>R":
        condition = (dataframe[indicator].shift(decalage).div(dataframe[crossed_indicator].shift(decalage)) > real_num)
    elif operator == "/=R":
        condition = (np.isclose(dataframe[indicator].shift(decalage).div(dataframe[crossed_indicator].shift(decalage)),
                                real_num))
    elif operator == "/<R":
        condition = (dataframe[indicator].shift(decalage).div(dataframe[crossed_indicator].shift(decalage)) < real_num)
    elif operator == "UT":
        condition = (dataframe[indicator].shift(decalage) > dataframe[indicator_trend_sma].shift(decalage))
    elif operator == "DT":
        condition = (dataframe[indicator].shift(decalage) < dataframe[indicator_trend_sma].shift(decalage))
    elif operator == "OT":
        condition = (np.isclose(dataframe[indicator].shift(decalage), dataframe[indicator_trend_sma].shift(decalage)))
    elif operator == "CUT":
        condition = (
            (
                    qtpylib.crossed_above(dataframe[indicator].shift(decalage),
                                          dataframe[indicator_trend_sma].shift(decalage))
            ) &
            (
                dataframe[indicator].shift(decalage) > dataframe[indicator_trend_sma].shift(decalage)
            )
        )
    elif operator == "CDT":
        condition = (
            (
                    qtpylib.crossed_below(dataframe[indicator].shift(decalage),
                                          dataframe[indicator_trend_sma].shift(decalage))
            ) &
            (
                dataframe[indicator].shift(decalage) < dataframe[indicator_trend_sma].shift(decalage)
            )
        )
    elif operator == "COT":
        condition = (
            (
                (
                            qtpylib.crossed_below(dataframe[indicator].shift(decalage),
                                                  dataframe[indicator_trend_sma].shift(decalage))
                ) |
                (
                            qtpylib.crossed_above(dataframe[indicator].shift(decalage),
                                                  dataframe[indicator_trend_sma].shift(decalage))
                )
            ) &
            (
                np.isclose(dataframe[indicator].shift(decalage), dataframe[indicator_trend_sma].shift(decalage))
            )
        )
    return condition, dataframe

class Zeus_AI(IStrategy):

    # *    1/43:     86 trades. 72/6/8 Wins/Draws/Losses. Avg profit  12.66%. Median profit  11.99%. Total profit  0.10894395 BTC ( 108.94Σ%). Avg duration 3 days, 0:31:00 min. Objective: -48.48793
    # "max_open_trades": 10,
    # "stake_currency": "BTC",
    # "stake_amount": 0.01,
    # "tradable_balance_ratio": 0.99,
    # "timeframe": "4h",
    # "dry_run_wallet": 0.1,

    # Buy hyperspace params:
    buy_b_params = {
        "buy_b_cat": "<R",
        "buy_b_real": 0.0128,
    }

    # Sell hyperspace params:
    sell_b_params = {
        "sell_b_cat": "=R",
        "sell_b_real": 0.9455,
    }

    # Buy hyperspace params:
    buy_h_params = {
        "buy_h_cat": "<R",
        "buy_h_real": 0.0128,
    }

    # Sell hyperspace params:
    sell_h_params = {
        "sell_h_cat": "=R",
        "sell_h_real": 0.9455,
    }

    # ROI table:
    minimal_roi = {
        "0": 0.564,
        "567": 0.273,
        "2814": 0.12,
        "7675": 0
    }

    # Stoploss:
    stoploss = -1 #0.256

    # sell_h_real = DecimalParameter(0.001, 0.999, decimals=4, default=0.59608, space='sell')
    # sell_h_cat = CategoricalParameter([">R", "=R", "<R"], default='>R', space='sell')

    # Buy hypers
    timeframe = '5m'

    market_overview = {'up': 0, 'down': 0}
    market_overview_pct5 = 0
    market_overview_pct1 = 0
    max_open_trades = 5
    max_amount = 40

    # DCA config
    position_adjustment_enable = True
    #max_dca_orders = 2  # n - 1
    max_dca_multiplier = 7  # (2^n - 1)
    dca_trigger = 0

    plot_config = {
        "main_plot": {
            "min200": {
                "color": "#86c932"
            },
            "max50": {
                "color": "white"
            },
            "max200": {
                "color": "yellow"
            },
            "sma3_1d": {
                "color": "pink"
            },
            "sma5_1d": {
                "color": "blue"
            },
            "sma10_1d": {
                "color": "orange"
            },
            "close_1d": {
                "color": "#73e233",
            },
            "bb_lowerband": {
                "color": "#da59a6"},
            "bb_upperband": {
                "color": "#da59a6",
            },
            "sar": {
                "color": "#4f9f51",
            }
        },
        "subplots": {
            "Ind": {
                "trend_ichimoku_base": {
                    "color": "#dd1384"
                },
                "trend_kst_diff": {
                    "color": "#850678"
                }
            },
            "BB": {
                "bb_width": {
                    "color": "white"
                },
                "bb_lower_5": {
                    "color": "yellow"
                }
            },
            "Cond": {
                "cond1": {
                    "color": "yellow"
                }
            },
            "Rsi": {
                "rsi": {
                    "color": "pink"
                },
                "rsi_1d": {
                    "color": "yellow"
                }
            },
            "Percent": {
                "max_min": {
                    "color": "#74effc"
                },
                "pct_change_1_1d": {
                    "color": "green"
                },
                "pct_change_3_1d": {
                    "color": "orange"
                },
                "pct_change_5_1d": {
                    "color": "red"
                }
            }
        }
    }
    trades = list()

    buy_min_horizon = IntParameter(50, 200, default=72, space='buy')

    buy_0_percent20 = DecimalParameter(-0.1, 0.1, decimals=2,  default=-0.02, space='buy')
    buy_2_percent20 = DecimalParameter(-0.1, 0.1, decimals=2,  default=-0.02, space='buy')
    buy_3_percent20 = DecimalParameter(-0.1, 0.1, decimals=2,  default=-0.02, space='buy')

    buy_0_distance = DecimalParameter(-0.1, 0.1, decimals=2, default=0.02, space='buy')
    buy_2_distance = DecimalParameter(-0.1, 0.1, decimals=2, default=0.02, space='buy')
    buy_3_distance = DecimalParameter(-0.1, 0.1, decimals=2, default=0.02, space='buy')

    buy_decalage_deb_0 = IntParameter(0, 3, default=5, space='buy')
    buy_decalage_deb_2 = IntParameter(0, 3, default=5, space='buy')
    buy_decalage_deb_3 = IntParameter(0, 3, default=5, space='buy')

    buy_real_num0 = DecimalParameter(0, 1, decimals=2,  default=0.67, space='buy')
    buy_real_num1 = DecimalParameter(0, 1, decimals=2,  default=0.67, space='buy')
    buy_real_num2 = DecimalParameter(0, 2, decimals=2,  default=0.67, space='buy')

    buy_decalage0 = IntParameter(buy_decalage_deb_0.value + 1, 8, default=5, space='buy')
    buy_decalage2 = IntParameter(buy_decalage_deb_2.value + 1, 8, default=5, space='buy')
    buy_decalage3 = IntParameter(buy_decalage_deb_3.value + 1, 8, default=5, space='buy')

    buy_1_bb_lower_5 = DecimalParameter(0, 0.6, decimals=2,  default=0.7, space='buy')
    buy_2_bb_lower_5 = DecimalParameter(0, 0.6, decimals=2,  default=0.7, space='buy')
    buy_3_bb_lower_5 = DecimalParameter(0, 0.6, decimals=2,  default=0.7, space='buy')

    buy_b_real = DecimalParameter(0.001, 0.999, decimals=4, default=0.11908, space='buy')
    buy_b_cat = CategoricalParameter([">R", "=R", "<R"], default='<R', space='buy')
    buy_b_pct = DecimalParameter(0.001, 0.02, decimals=3, default=0.005, space='buy')
    buy_b_pct_1 = DecimalParameter(-0.2, 0.2, decimals=2, default=0.005, space='buy')
    buy_b_pct_3 = DecimalParameter(-0.2, 0.2, decimals=2, default=0.005, space='buy')
    buy_b_pct_5 = DecimalParameter(-0.2, 0.2, decimals=2, default=0.005, space='buy')
    buy_b_bb_lowerband = DecimalParameter(1, 1.05, default=1, decimals=2, space='buy')
    buy_b_bb_width = DecimalParameter(0.01, 0.15, default=0.065, decimals=2, space='buy')

    decalage_h = IntParameter(0, 3, default=0, space='buy')
    decalage_b = IntParameter(0, 3, default=0, space='buy')

    buy_h_real = DecimalParameter(0.001, 0.999, decimals=4, default=0.11908, space='buy')
    buy_h_cat = CategoricalParameter([">R", "=R", "<R"], default='<R', space='buy')
    buy_h_pct = DecimalParameter(0.001, 0.02, decimals=3, default=0.005, space='buy')
    buy_h_pct_1 = DecimalParameter(-0.2, 0.2, decimals=2, default=0.005, space='buy')
    buy_h_pct_3 = DecimalParameter(-0.2, 0.2, decimals=2, default=0.005, space='buy')
    buy_h_pct_5 = DecimalParameter(-0.2, 0.2, decimals=2, default=0.005, space='buy')
    buy_h_bb_lowerband = DecimalParameter(1, 1.05, default=1, decimals=2, space='buy')
    buy_h_bb_width = DecimalParameter(0.01, 0.15, default=0.065, decimals=2, space='buy')

    buy_h_sma = CategoricalParameter(["sma3_1d", "sma5_1d", "sma10_1d"], default='sma10_1d', space='buy')
    buy_b_sma = CategoricalParameter(["sma3_1d", "sma5_1d", "sma10_1d"], default='sma10_1d', space='buy')
    buy_h_sma_close = CategoricalParameter(["sma3_1d", "sma5_1d", "sma10_1d"], default='sma3_1d', space='buy')
    buy_b_sma_close = CategoricalParameter(["sma3_1d", "sma5_1d", "sma10_1d"], default='sma3_1d', space='buy')

    buy_base = DecimalParameter(0, 0.2, decimals=2, default=0.08, space='buy')
    buy_rsi = IntParameter(20, 90, default=72, space='buy')
    buy_bb_width_n = DecimalParameter(1, 10, decimals=1, default=5, space='buy')

    buy_min_max_nh = IntParameter(1, 48, default=24, space='buy')
    buy_min_max_n = DecimalParameter(0, 0.2, decimals=2, default=0.05, space='buy')
    buy_min_max_cond1 = DecimalParameter(0, 2, decimals=1, default=1.2, space='buy')
    buy_min_max_rsi = IntParameter(50, 90, default=72, space='buy')
    buy_min_max_coef = DecimalParameter(1, 1.01, decimals=3, default=1.002, space='buy')
    buy_min_max_decalage = IntParameter(2, 10, default=2, space='buy')

    profit_b_no_change = BooleanParameter(default=True, space="sell")
    profit_b_quick_lost = BooleanParameter(default=True, space="sell")
    profit_b_sma5 = BooleanParameter(default=True, space="sell")
    profit_b_sma10 = BooleanParameter(default=True, space="sell")
    profit_b_sma20 = BooleanParameter(default=True, space="sell")
    profit_b_quick_gain = BooleanParameter(default=True, space="sell")
    profit_b_quick_gain_3 = BooleanParameter(default=True, space="sell")
    profit_b_old_sma10 = BooleanParameter(default=True, space="sell")
    profit_b_very_old_sma10 = BooleanParameter(default=True, space="sell")
    profit_b_over_rsi = BooleanParameter(default=True, space="sell")
    profit_b_short_loss = BooleanParameter(default=True, space="sell")

    sell_b_percent = DecimalParameter(0, 0.02, decimals=3,  default=0.01, space='sell')
    sell_b_percent3 = DecimalParameter(0, 0.02, decimals=3,  default=0.01, space='sell')
    sell_b_candels = IntParameter(0, 48, default=12, space='sell')

    sell_b_too_old_day = IntParameter(0, 10, default=5, space='sell')
    sell_b_too_old_percent = DecimalParameter(0, 0.02, decimals=3,  default=0.01, space='sell')

    sell_b_profit_no_change = DecimalParameter(0, 0.02, decimals=3,  default=0.005, space='sell')
    sell_b_profit_percent10 = DecimalParameter(0, 0.002, decimals=4,  default=0.001, space='sell')

    sell_b_RSI = IntParameter(70, 98, default=88, space='sell')
    sell_b_RSI2 = IntParameter(70, 98, default=88, space='sell')
    sell_b_RSI3 = IntParameter(70, 98, default=80, space='sell')

    sell_b_RSI2_percent = DecimalParameter(0, 0.02, decimals=3,  default=0.01, space='sell')
    # sell_b_expected_profit = DecimalParameter(0, 0.01, decimals=3,  default=0.01, space='sell')

    profit_h_no_change = BooleanParameter(default=True, space="sell")
    profit_h_quick_lost = BooleanParameter(default=True, space="sell")
    profit_h_sma5 = BooleanParameter(default=True, space="sell")
    profit_h_sma10 = BooleanParameter(default=True, space="sell")
    profit_h_sma20 = BooleanParameter(default=True, space="sell")
    profit_h_quick_gain = BooleanParameter(default=True, space="sell")
    profit_h_quick_gain_3 = BooleanParameter(default=True, space="sell")
    profit_h_old_sma10 = BooleanParameter(default=True, space="sell")
    profit_h_very_old_sma10 = BooleanParameter(default=True, space="sell")
    profit_h_over_rsi = BooleanParameter(default=True, space="sell")
    profit_h_short_loss = BooleanParameter(default=True, space="sell")

    sell_h_percent = DecimalParameter(0, 0.02, decimals=3,  default=0.01, space='sell')
    sell_h_percent3 = DecimalParameter(0, 0.02, decimals=3,  default=0.01, space='sell')
    sell_h_candels = IntParameter(0, 48, default=12, space='sell')

    sell_h_too_old_day = IntParameter(0, 10, default=5, space='sell')
    sell_h_too_old_percent = DecimalParameter(0, 0.02, decimals=3,  default=0.01, space='sell')

    sell_h_profit_no_change = DecimalParameter(0, 0.02, decimals=3,  default=0.005, space='sell')
    sell_h_profit_percent10 = DecimalParameter(0, 0.002, decimals=4,  default=0.001, space='sell')

    sell_h_RSI = IntParameter(70, 98, default=88, space='sell')
    sell_h_RSI2 = IntParameter(70, 98, default=88, space='sell')
    sell_h_RSI3 = IntParameter(70, 98, default=80, space='sell')

    sell_h_RSI2_percent = DecimalParameter(0, 0.02, decimals=3,  default=0.01, space='sell')
    # sell_h_expected_profit = DecimalParameter(0, 0.01, decimals=3,  default=0.01, space='sell')

    # protection_lost_percent = DecimalParameter(0, 0.2, decimals=2,  default=0.06, space='protection')
    # protection_lost_candles = IntParameter(1, 30, default=5, space='protection')
    protection_percent_buy_lost = IntParameter(1, 30, default=5, space='protection')
    protection_nb_buy_lost = IntParameter(1, 3, default=2, space='protection')
    protection_strategy = IntParameter(1, 5, default=1, space='protection')
    protection_strategy_amount = IntParameter(1, 5, default=2, space='protection')

    # protection_amount = []
    # protection_amount[1] = self.config['stake_amount']
    # protection_amount[2] = IntParameter(1, 10, default=2, space='protection')

    def custom_sell(self, pair: str, trade: 'Trade', current_time: 'datetime', current_rate: float,
                    current_profit: float, **kwargs):
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        last_candle = dataframe.iloc[-1].squeeze()
        previous_last_candle = dataframe.iloc[-2].squeeze()
        previous_5_candle = dataframe.iloc[-5].squeeze()

        expected_profit = 0.01
        #print(last_candle['buy_tag'])

        days = (current_time - trade.open_date_utc).days
        ######

        # if (
        #         (btc_last_candle['percent'] < -0.02) | (btc_last_candle['percent5'] < -0.04)) & (current_profit > -0.03):
        #     self.stop_buy_for_all = True
        #     return "btc_fall"

        # bb_width_lim = last_candle['bb_width'] / 4
        # bb_width_up = last_candle['bb_upperband'] * (1 - last_candle['bb_width'] / 5)

        if (last_candle['mrsi3_1h'] <= 0): #(self.market_overview_pct5 < 0) | (last_candle['pct_change_1_4h'] < 0):
            max_percent = 0.004  # last_candle['bb_width'] / 3.5  # 0.005
            max_profit = 0.004  # last_candle['bb_width'] * 3 / 4 # 0.015

            if (current_profit > 0.01) & \
                    (last_candle['percent10'] < -0.005) & ((current_time - trade.open_date_utc).seconds >= 3600):
                return 'b_percent10'
            if (current_profit > max_profit) & \
                    ((last_candle['percent'] < - max_percent) | (last_candle['percent3'] < -max_percent) | (
                            last_candle['percent5'] < -max_percent)):
                return 'b_percent_quick'

            if (current_profit >= - self.sell_b_too_old_percent.value) & (days >= self.sell_b_too_old_day.value)\
                    & (days < self.sell_b_too_old_day.value * 2)\
                    & (previous_last_candle['sma10'] > last_candle['sma10']) & (last_candle['percent3'] < 0):
                return "b_too_old_0.01"
            if (current_profit >= - self.sell_b_too_old_percent.value * 2) & (days >= self.sell_b_too_old_day.value * 2)\
                & (days < self.sell_b_too_old_day.value * 3) \
                    & (previous_last_candle['sma10'] > last_candle['sma10']) & (last_candle['percent3'] < 0):
                return "b_too_old_0.02"
            if (current_profit >= - self.sell_b_too_old_percent.value * 3) & (days >= self.sell_b_too_old_day.value * 3) \
                    & (previous_last_candle['sma10'] > last_candle['sma10']) & (last_candle['percent3'] < 0):
                return "b_too_old_0.03"

            if self.profit_b_quick_lost.value and (current_profit >= max_profit) & (
                    last_candle['percent3'] < -max_percent):
                return "b_quick_lost"

            if self.profit_b_no_change.value and (current_profit > self.sell_b_profit_no_change.value) \
                    & (last_candle['percent10'] < self.sell_b_profit_percent10.value) & (last_candle['percent5'] < 0) \
                    & ((current_time - trade.open_date_utc).seconds >= 3600):
                return "b_no_change"

            if (current_profit > self.sell_b_percent.value) & (last_candle['percent3'] < - self.sell_b_percent3.value) \
                    & ((current_time - trade.open_date_utc).seconds <= 300 * self.sell_b_candels.value):
                return "b_quick_gain_param"

            if self.profit_b_sma5.value:
                if (current_profit > expected_profit) \
                        & ((previous_5_candle['sma5'] > last_candle['sma5']) \
                           | (last_candle['percent3'] < -expected_profit) | (
                                   last_candle['percent5'] < -expected_profit)) \
                        & ((last_candle['percent'] < 0) & (last_candle['percent3'] < 0)):
                    # print("over_bb_band_sma10_desc", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'b_sma5'

            if self.profit_b_sma10.value:
                if (current_profit > expected_profit) \
                        & ((previous_5_candle['sma10'] > last_candle['sma10']) \
                           | (last_candle['percent3'] < -expected_profit) | (
                                   last_candle['percent5'] < -expected_profit)) \
                        & ((last_candle['percent'] < 0) & (last_candle['percent3'] < 0)):
                    # print("over_bb_band_sma10_desc", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'b_sma10'

            if self.profit_b_sma20.value:
                if (current_profit > max_percent) \
                        & (previous_last_candle['sma10'] > last_candle['sma10']) \
                        & ((current_time - trade.open_date_utc).seconds >= 3600) \
                        & ((previous_last_candle['sma20'] > last_candle['sma20']) &
                           ((last_candle['percent5'] < 0) | (last_candle['percent10'] < 0) | (
                                   last_candle['percent20'] < 0))):
                    # print("over_bb_band_sma10_desc", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'b_sma20'

            if self.profit_b_over_rsi.value:
                if (current_profit > 0) & (previous_last_candle[
                                               'rsi'] > self.sell_b_RSI.value):  # & (last_candle['percent'] < 0): #| (previous_last_candle['rsi'] > 75 & last_candle['rsi'] < 70)):
                    # print("over_rsi", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'b_over_rsi'

                if (current_profit > 0) & (previous_last_candle['rsi'] > self.sell_b_RSI2.value) & \
                        (last_candle[
                             'percent'] < - self.sell_b_RSI2_percent.value):  # | (previous_last_candle['rsi'] > 75 & last_candle['rsi'] < 70)):
                    # print("over_rsi", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'b_over_rsi_2'

                if (current_profit > 0) & (previous_last_candle['rsi'] > self.sell_b_RSI3.value) & \
                        (last_candle['close'] >= last_candle['max200']) & (last_candle[
                                                                               'percent'] < - self.sell_b_RSI2_percent.value):  # | (previous_last_candle['rsi'] > 75 & last_candle['rsi'] < 70)):
                    # print("over_rsi", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'b_over_rsi_max'

            if self.profit_b_short_loss.value:
                if (current_profit > -expected_profit) & (previous_last_candle['percent10'] > 0.04) & (
                        last_candle['percent'] < 0) \
                        & (days >= 1): #| (previous_last_candle['rsi'] > 75 & last_candle['rsi'] < 70)):
                    # print("over_rsi", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'b_short_lost'
        else:
            max_percent = 0.005  # last_candle['bb_width'] / 3.5  # 0.005
            max_profit = 0.01  # last_candle['bb_width'] * 3 / 4 # 0.015

            if (current_profit > max_profit) & (
                    (last_candle['percent'] < -max_percent) | (last_candle['percent3'] < -max_percent) | (
                    last_candle['percent5'] < -max_percent)):
                return 'h_percent_quick'

            # if (last_candle['bb_width'] < 0.02) & (current_profit > 0) & (last_candle['close'] > bb_width_up) & \
            #     ((last_candle['percent'] < - bb_width_lim) | (last_candle['percent3'] < - bb_width_lim) | (last_candle['percent5'] < - bb_width_lim)):
            #     return 'h_bb_width_max'

            if (current_profit >= - self.sell_h_too_old_percent.value) & (days >= self.sell_h_too_old_day.value)\
                    & (days < self.sell_h_too_old_day.value * 2)\
                    & (previous_last_candle['sma10'] > last_candle['sma10']) & (last_candle['percent3'] < 0):
                return "h_too_old_0.01"
            if (current_profit >= - self.sell_h_too_old_percent.value * 2) & (days >= self.sell_h_too_old_day.value * 2)\
                & (days < self.sell_h_too_old_day.value * 3) \
                    & (previous_last_candle['sma10'] > last_candle['sma10']) & (last_candle['percent3'] < 0):
                return "h_too_old_0.02"
            if (current_profit >= - self.sell_h_too_old_percent.value * 3) & (days >= self.sell_h_too_old_day.value * 3) \
                    & (previous_last_candle['sma10'] > last_candle['sma10']) & (last_candle['percent3'] < 0):
                return "h_too_old_0.03"

            if self.profit_h_quick_lost.value and (current_profit >= max_profit) & (
                    last_candle['percent3'] < -max_percent):
                return "h_quick_lost"

            if self.profit_h_no_change.value and (current_profit > self.sell_h_profit_no_change.value) \
                    & (last_candle['percent10'] < self.sell_h_profit_percent10.value) & (last_candle['percent5'] < 0) \
                    & ((current_time - trade.open_date_utc).seconds >= 3600):
                return "h_no_change"

            if (current_profit > self.sell_h_percent.value) & (last_candle['percent3'] < - self.sell_h_percent3.value) \
                    & ((current_time - trade.open_date_utc).seconds <= 300 * self.sell_h_candels.value):
                return "h_quick_gain_param"

            if self.profit_h_sma5.value:
                if (current_profit > expected_profit) \
                        & ((previous_5_candle['sma5'] > last_candle['sma5']) \
                           | (last_candle['percent3'] < -expected_profit) | (
                                   last_candle['percent5'] < -expected_profit)) \
                        & ((last_candle['percent'] < 0) & (last_candle['percent3'] < 0)):
                    # print("over_bb_band_sma10_desc", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'h_sma5'

            if self.profit_h_sma10.value:
                if (current_profit > expected_profit) \
                        & ((previous_5_candle['sma10'] > last_candle['sma10']) \
                           | (last_candle['percent3'] < -expected_profit) | (
                                   last_candle['percent5'] < -expected_profit)) \
                        & ((last_candle['percent'] < 0) & (last_candle['percent3'] < 0)):
                    # print("over_bb_band_sma10_desc", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'h_sma10'

            if self.profit_h_sma20.value:
                if (current_profit > max_percent) \
                        & (previous_last_candle['sma10'] > last_candle['sma10']) \
                        & ((current_time - trade.open_date_utc).seconds >= 3600) \
                        & ((previous_last_candle['sma20'] > last_candle['sma20']) &
                           ((last_candle['percent5'] < 0) | (last_candle['percent10'] < 0) | (
                                   last_candle['percent20'] < 0))):
                    # print("over_bb_band_sma10_desc", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'h_sma20'

            if self.profit_h_over_rsi.value:
                if (current_profit > 0) & (previous_last_candle[
                                               'rsi'] > self.sell_h_RSI.value):  # & (last_candle['percent'] < 0): #| (previous_last_candle['rsi'] > 75 & last_candle['rsi'] < 70)):
                    # print("over_rsi", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'h_over_rsi'

                if (current_profit > 0) & (previous_last_candle['rsi'] > self.sell_h_RSI2.value) & \
                        (last_candle[
                             'percent'] < - self.sell_h_RSI2_percent.value):  # | (previous_last_candle['rsi'] > 75 & last_candle['rsi'] < 70)):
                    # print("over_rsi", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'h_over_rsi_2'

                if (current_profit > 0) & (previous_last_candle['rsi'] > self.sell_h_RSI3.value) & \
                        (last_candle['close'] >= last_candle[
                            'max200']):  # | (previous_last_candle['rsi'] > 75 & last_candle['rsi'] < 70)):
                    # print("over_rsi", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'h_over_rsi_max'

            if self.profit_h_short_loss.value:
                if (current_profit > -expected_profit) & (previous_last_candle['percent10'] > 0.04) & (
                        last_candle['percent'] < 0) \
                        & (days >= 1): #| (previous_last_candle['rsi'] > 75 & last_candle['rsi'] < 70)):
                    # print("over_rsi", pair, trade, " profit=", current_profit, " rate=", current_rate)
                    return 'h_short_lost'

    def informative_pairs(self):
        # get access to all pairs available in whitelist.
        pairs = self.dp.current_whitelist()
        informative_pairs = [(pair, '1d') for pair in pairs]
        informative_pairs += [(pair, '4h') for pair in pairs]
        informative_pairs += [(pair, '1h') for pair in pairs]

        corr_pairs = self.config["freqai"]["feature_parameters"]["include_corr_pairlist"]
        for tf in self.config["freqai"]["feature_parameters"]["include_timeframes"]:
            for pair in pairs:
                informative_pairs.append((pair, tf))
            for pair in corr_pairs:
                if pair in pairs:
                    continue  # avoid duplication
                informative_pairs.append((pair, tf))

        return informative_pairs

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        # Add all ta features
        dataframe = self.freqai.start(dataframe, metadata, self)
        return dataframe

    def populate_any_indicators(self, pair, dataframe, tf, informative=None, set_generalized_indicators=False):
        dataframe['trend_ichimoku_base'] = ta.trend.ichimoku_base_line(
            dataframe['high'],
            dataframe['low'],
            window1=9,
            window2=26,
            visual=False,
            fillna=False
        )
        KST = ta.trend.KSTIndicator(
            close=dataframe['close'],
            roc1=10,
            roc2=15,
            roc3=20,
            roc4=30,
            window1=10,
            window2=10,
            window3=10,
            window4=15,
            nsig=9,
            fillna=False
        )

        dataframe['trend_kst_diff'] = KST.kst_diff()
        dataframe['pct_change'] = dataframe['close'].pct_change(5)
        dataframe['min'] = talib.MIN(dataframe['close'], timeperiod=self.buy_min_horizon.value)
        dataframe['min10'] = talib.MIN(dataframe['close'], timeperiod=10)
        dataframe['min20'] = talib.MIN(dataframe['close'], timeperiod=20)
        dataframe['min50'] = talib.MIN(dataframe['close'], timeperiod=50)
        dataframe['min200'] = talib.MIN(dataframe['close'], timeperiod=200)
        dataframe['min200_1'] = dataframe['min200'] * 1.005
        dataframe['moy200_12'] = dataframe['min200'].rolling(12).mean() 

        dataframe['max50'] = talib.MAX(dataframe['close'], timeperiod=50)
        dataframe['max200'] = talib.MAX(dataframe['close'], timeperiod=200)
        dataframe['min_max200'] = (dataframe['max200'] - dataframe['min200']) / dataframe['min200']  
        dataframe['min_n'] = talib.MIN(dataframe['close'], timeperiod=12 * self.buy_min_max_nh.value)
        dataframe['max_n'] = talib.MAX(dataframe['close'], timeperiod=12 * self.buy_min_max_nh.value)
        dataframe['min_max_n'] = (dataframe['max_n'] - dataframe['min_n']) / dataframe['min_n']
        dataframe['rsi'] = talib.RSI(dataframe)
        dataframe['rsi5'] = talib.RSI(dataframe, timeperiod=5)
        dataframe['sma5'] = talib.SMA(dataframe, timeperiod=5)
        dataframe['sma10'] = talib.SMA(dataframe, timeperiod=10)
        dataframe['sma20'] = talib.SMA(dataframe, timeperiod=20)
        dataframe['sma50'] = talib.SMA(dataframe, timeperiod=50)
        dataframe['sma100'] = talib.SMA(dataframe, timeperiod=100)
        dataframe["percent"] = (dataframe["close"] - dataframe["open"]) / dataframe["open"]
        dataframe["percent5"] = dataframe["percent"].rolling(5).sum()
        dataframe["percent3"] = dataframe["percent"].rolling(3).sum()
        dataframe["percent10"] = dataframe["percent"].rolling(10).sum()
        dataframe["percent20"] = dataframe["percent"].rolling(20).sum()
        dataframe["percent50"] = dataframe["percent"].rolling(50).sum()
        # dataframe['percent_lost_n'] = dataframe["percent"].rolling(self.protection_lost_candles.value).sum()
        dataframe["volume10"] = dataframe["volume"].rolling(10).mean()
        # Bollinger Bands
        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
        dataframe['bb_lowerband'] = bollinger['lower']
        dataframe['bb_middleband'] = bollinger['mid']
        dataframe['bb_upperband'] = bollinger['upper']
        dataframe["bb_percent"] = (
            (dataframe["close"] - dataframe["bb_lowerband"]) /
            (dataframe["bb_upperband"] - dataframe["bb_lowerband"])
        )
        dataframe["bb_width"] = (
            (dataframe["bb_upperband"] - dataframe["bb_lowerband"]) / dataframe["bb_middleband"]
        )
        dataframe['bb_lower_var_5'] = (dataframe['bb_lowerband'] - dataframe['min50']).rolling(5).var()
        dataframe['bb_lower_5'] = 100 * ((dataframe['bb_lowerband'].rolling(5).mean() / dataframe['bb_lowerband']) - 1)
        dataframe['bb_lower_width_5'] = (dataframe['bb_lowerband'] * (1 + dataframe['bb_width'] / self.buy_bb_width_n.value))

        # dataframe['bb_min'] = ta.MIN(dataframe['bb_lowerband'], timeperiod=36)

        dataframe['distance_min'] = (dataframe['close'] - dataframe['min']) / dataframe['close']
        dataframe['min1.1'] = 1.01 * dataframe['min']
        dataframe['normal'] = 100 * (dataframe['close'] / dataframe['close'].rolling(200).mean())
        # dataframe['normal_var_20'] = dataframe['normal'].rolling(20).var()
        # dataframe['normal_var_50'] = dataframe['normal'].rolling(50).var()

        dataframe['min_max_close'] = (
                    (dataframe['max200'] - dataframe['close']) / (dataframe['close'] - dataframe['min200']))
        dataframe['sar'] = talib.SAR(dataframe)
        # Normalization
        tib = dataframe['trend_ichimoku_base']
        dataframe['trend_ichimoku_base'] = (tib-tib.min())/(tib.max()-tib.min())
        tkd = dataframe['trend_kst_diff']
        dataframe['trend_kst_diff'] = (tkd-tkd.min())/(tkd.max()-tkd.min())

        dataframe[buy_crossed_indicator0] = gene_calculator(dataframe, buy_crossed_indicator0)
        dataframe[buy_crossed_indicator1] = gene_calculator(dataframe, buy_crossed_indicator1)
        dataframe[buy_crossed_indicator2] = gene_calculator(dataframe, buy_crossed_indicator2)

        dataframe[buy_indicator0] = gene_calculator(dataframe, buy_indicator0)
        dataframe[buy_indicator1] = gene_calculator(dataframe, buy_indicator1)
        dataframe[buy_indicator2] = gene_calculator(dataframe, buy_indicator2)

        dataframe["cond1"] = dataframe[buy_indicator0].div(dataframe[buy_crossed_indicator0])
        dataframe['atr'] = talib.ATR(dataframe, timeperiod=14)

        ################### INFORMATIVE 1D
        informative = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe="1d")
        informative["rsi"] = talib.RSI(informative)
        informative["max3"] = talib.MAX(informative['close'], timeperiod=3)
        informative["min3"] = talib.MIN(informative['close'], timeperiod=3)
        informative['pct_change_1'] = informative['close'].pct_change(1)
        informative['pct_change_3'] = informative['close'].pct_change(3)
        informative['pct_change_5'] = informative['close'].pct_change(5)
        informative['sma3'] = talib.SMA(informative, timeperiod=3)
        informative['sma5'] = talib.SMA(informative, timeperiod=5)
        informative['sma10'] = talib.SMA(informative, timeperiod=10)
        informative['sar'] = talib.SAR(informative)

        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(informative), window=20, stds=2)
        informative['bb_lowerband'] = bollinger['lower']
        informative['bb_middleband'] = bollinger['mid']
        informative['bb_upperband'] = bollinger['upper']
        informative["bb_percent"] = (
            (informative["close"] - informative["bb_lowerband"]) /
            (informative["bb_upperband"] - informative["bb_lowerband"])
        )
        informative["bb_width"] = (
            (informative["bb_upperband"] - informative["bb_lowerband"]) / informative["bb_middleband"]
        )

        dataframe = merge_informative_pair(dataframe, informative, self.timeframe, "1d", ffill=True)

        ######################## INFORMATIVE 4h
        informative = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe="4h")
        informative["rsi"] = talib.RSI(informative)
        informative['pct_change_1'] = informative['close'].pct_change(1)
        informative['pct_change_3'] = informative['close'].pct_change(3)
        informative['pct_change_5'] = informative['close'].pct_change(5)
        informative['sma3'] = talib.SMA(informative, timeperiod=3)
        informative['sma5'] = talib.SMA(informative, timeperiod=5)
        informative['sma10'] = talib.SMA(informative, timeperiod=10)
        dataframe = merge_informative_pair(dataframe, informative, self.timeframe, "4h", ffill=True)

        ######################## INFORMATIVE 1h
        informative = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe="1h")
        informative["rsi"] = talib.RSI(informative)
        informative["mrsi3"] = informative["rsi"].rolling(3).mean()
        informative['pct_change_1'] = informative['close'].pct_change(1)
        informative['pct_change_3'] = informative['close'].pct_change(3)
        informative['pct_change_5'] = informative['close'].pct_change(5)
        informative['sma3'] = talib.SMA(informative, timeperiod=3)
        informative['sma5'] = talib.SMA(informative, timeperiod=5)
        informative['sma10'] = talib.SMA(informative, timeperiod=10)
        dataframe = merge_informative_pair(dataframe, informative, self.timeframe, "1h", ffill=True)

        """
        Function designed to automatically generate, name and merge features
        from user indicated timeframes in the configuration file. User controls the indicators
        passed to the training/prediction by prepending indicators with `'%-' + coin `
        (see convention below). I.e. user should not prepend any supporting metrics
        (e.g. bb_lowerband below) with % unless they explicitly want to pass that metric to the
        model.
        :param pair: pair to be used as informative
        :param df: strategy dataframe which will receive merges from informatives
        :param tf: timeframe of the dataframe which will modify the feature names
        :param informative: the dataframe associated with the informative pair
        :param coin: the name of the coin which will modify the feature names.
        """

        coin = pair.split('/')[0]

        if informative is None:
            informative = self.dp.get_pair_dataframe(pair, tf)

        # first loop is automatically duplicating indicators for time periods
        for t in self.freqai_info["feature_parameters"]["indicator_periods_candles"]:
            t = int(t)
            informative[f"%-{coin}rsi-period_{t}"] = ta.RSI(informative, timeperiod=t)
            informative[f"%-{coin}mfi-period_{t}"] = ta.MFI(informative, timeperiod=t)
            informative[f"%-{coin}adx-period_{t}"] = ta.ADX(informative, window=t)

        indicators = [col for col in informative if col.startswith("%")]
        # This loop duplicates and shifts all indicators to add a sense of recency to data
        for n in range(self.freqai_info["feature_parameters"]["include_shifted_candles"] + 1):
            if n == 0:
                continue
            informative_shift = informative[indicators].shift(n)
            informative_shift = informative_shift.add_suffix("_shift-" + str(n))
            informative = pandas.concat((informative, informative_shift), axis=1)

        dataframe = merge_informative_pair(dataframe, informative, self.config["timeframe"], tf, ffill=True)
        skip_columns = [
            (s + "_" + tf) for s in ["date", "open", "high", "low", "close", "volume"]
        ]
        dataframe = dataframe.drop(columns=skip_columns)

        # Add generalized indicators here (because in live, it will call this
        # function to populate indicators during training). Notice how we ensure not to
        # add them multiple times
        if set_generalized_indicators:

            # user adds targets here by prepending them with &- (see convention below)
            # If user wishes to use multiple targets, a multioutput prediction model
            # needs to be used such as templates/CatboostPredictionMultiModel.py
            dataframe["&-s_close"] = (
                dataframe["close"]
                .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
                .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
                .mean()
                / dataframe["close"]
                - 1
            )

        return dataframe

    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (
               (dataframe['trend_ichimoku_base'] <= self.buy_base.value)
               & (dataframe['rsi'] < self.buy_rsi.value)
               & (dataframe['close'] < dataframe['sma10'])
               & (dataframe['close'] < dataframe['bb_lower_width_5'])
               # & (dataframe['min50'] == dataframe['min50'].shift(3))
                # & (dataframe['min50'].shift(2) == dataframe['min50'])
               # & (dataframe['close'] <= dataframe['close_1d'])
               & (dataframe['close'] <= dataframe['close_1h'])
            ), ['buy', 'buy_tag']] = (1, 'buy_ichimoku')

        dataframe.loc[
            (
                (dataframe['min_max_n'] >= self.buy_min_max_n.value)
                & (dataframe['cond1'].shift(self.buy_min_max_decalage.value) <= self.buy_min_max_cond1.value)
                & (dataframe['rsi'] < self.buy_min_max_rsi.value)
                & (dataframe['close'] < dataframe['min_n'] * self.buy_min_max_coef.value)
                & (dataframe['min_n'].shift(self.buy_min_max_decalage.value) == dataframe['min_n'])
                & (dataframe['pct_change_1_1d'] > 0)
                # & (dataframe['min50'] == dataframe['min50'].shift(3))
                # & (dataframe['close'] <= dataframe['close_1d'])
                & (dataframe['close'] <= dataframe['close_1h'])
            ), ['buy', 'buy_tag']] = (1, 'buy_min_max')
        return dataframe

    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:

        return dataframe

    def adjust_trade_position(self, trade: Trade, current_time: datetime,
                              current_rate: float, current_profit: float, min_stake: float,
                              max_stake: float, **kwargs):
        dataframe, _ = self.dp.get_analyzed_dataframe(trade.pair, self.timeframe)
        if (len(dataframe) < 1):
            return None
        last_candle = dataframe.iloc[-1].squeeze()
        last_candle_5 = dataframe.iloc[-3].squeeze()

        min_d = min(last_candle['sma3_4h'], last_candle['close_1d'])

        filled_buys = trade.select_filled_orders('buy')
        count_of_buys = len(filled_buys)
        days = (current_time - trade.open_date_utc).days
        minutes = (current_time - trade.open_date_utc).seconds / 60
        # condition = (last_candle['cond1'] <= 0.75) & (last_candle['bb_width'] > 0.018) & (
        #             last_candle['rsi'] < 72) & (last_candle['close'] < last_candle['min50'] * 1.006)# & (last_candle['min_max_close'] > 2)

        condition = (last_candle['min50'] == last_candle_5['min50']) & (last_candle['close'] <= last_candle['close_1h'])
        p = self.protection_percent_buy_lost.value
        percents = [p, p * 2, p * 3, p * 4, p * 5, p * 6, p * 7, p * 8, p * 9]

        if (0 < count_of_buys <= self.protection_nb_buy_lost.value) \
                & (current_profit < - (percents[count_of_buys - 1] / 100)) & (condition):
            try:
                p = self.config['stake_amount']
                factors = [p, p, p, p, 2 * p, 4 * p, 5 * p, 6 * p]

                stake_amount = factors[count_of_buys - 1]# filled_buys[0].cost
                # This then calculates current safety order size
                # stake_amount = stake_amount * pow(1.5, count_of_buys)
                print("-----------" + trade.pair + " " + str(current_profit) + " " + str(count_of_buys) + " " + str(stake_amount) + "---------------------")
                return stake_amount
            except Exception as exception:
                print(exception)
                return None
        return None