# Heracles Strategy: Strongest Son of GodStra
# ( With just 1 Genome! its a bacteria :D )
# Author: @Mablue (Masoud Azizi)
# github: https://github.com/mablue/
# IMPORTANT:Add to your pairlists inside config.json (Under StaticPairList):
#   {
#       "method": "AgeFilter",
#       "min_days_listed": 100
#   },
# IMPORTANT: INSTALL TA BEFOUR RUN(pip install ta)
#
# freqtrade hyperopt --hyperopt-loss SharpeHyperOptLoss --spaces roi buy --strategy Heracles
# ######################################################################
# --- Do not remove these libs ---
from freqtrade.persistence import Trade
from typing import Optional, Tuple, Union
from datetime import timezone, timedelta, datetime
from freqtrade.strategy import (BooleanParameter, CategoricalParameter, DecimalParameter, stoploss_from_open,
                                IntParameter, IStrategy, merge_informative_pair, informative, stoploss_from_absolute)
import logging

# noinspection PyUnresolvedReferences
from freqtrade.strategy import (IStrategy, informative)
from pandas import DataFrame
# --------------------------------
# Add your lib to import here
# import talib.abstract as ta
import pandas as pd
import ta
import talib.abstract as talib
from ta.utils import dropna
import freqtrade.vendor.qtpylib.indicators as qtpylib
from functools import reduce
import numpy as np


class HeikinAshi(IStrategy):
    plot_config = {
        "main_plot": {
            "min12": {
                "color": "#197260"
            },
            'max12': {
                'color': 'green'
            },
            "haclose": {
                "color": "red"
            },
            'haopen': {
                'color': 'blue'
            },
            "min288": {
                "color": "#197260"
            },
            'max288': {
                'color': 'green'
            },
            'mid288': {
                'color': 'blue'
            }
        },
        "subplots": {
            "Percent": {
                "hapercent": {
                    "color": "#74effc"
                }
            }
        }

    }

    # Buy hyperspace params:
    buy_params = {
        "buy_crossed_indicator_shift": 9,
        "buy_div_max": 0.75,
        "buy_div_min": 0.16,
        "buy_indicator_shift": 15,
    }

    # Sell hyperspace params:
    sell_params = {
    }

    # ROI table:
    minimal_roi = {
        "0": 0.598
    }

    # Stoploss:
    stoploss = -1

    # Optimal timeframe use it in your config
    timeframe = '5m'
    columns_logged = False
    max_entry_position_adjustment = 20
    startup_candle_count = 288

    # Trailing stoploss
    # trailing_stop = False
    # trailing_stop_positive = 0.001
    # trailing_stop_positive_offset = 0.015
    # trailing_only_offset_is_reached = True
    position_adjustment_enable = False

    pairs = {
        pair: {
            "last_max": 0,
            "trade_info": {},
            "max_touch": 0.0,
            "last_sell": 0.0,
            "last_buy": 0.0
        }
        for pair in ["BTC/USDT", "ETH/USDT", "DOGE/USDT", "DASH/USDT", "XRP/USDT", "SOL/USDT"]
    }

    decalage = IntParameter(0, 48, default=12, space='buy')

    ########################################## END RESULT PASTE PLACE #####################################
    # ------------------------------------------------------------------------------------------------------------------
    def adjust_trade_position(self, trade: Trade, current_time: datetime,
                              current_rate: float, current_profit: float,
                              min_stake: Optional[float], max_stake: float,
                              current_entry_rate: float, current_exit_rate: float,
                              current_entry_profit: float, current_exit_profit: float,
                              **kwargs
                              ) -> Union[Optional[float], Tuple[Optional[float], Optional[str]]]:


        # ne rien faire si ordre deja en cours
        if trade.has_open_orders:
            return None

        dataframe, _ = self.dp.get_analyzed_dataframe(trade.pair, self.timeframe)
        last_candle = dataframe.iloc[-1].squeeze()
        last_candle_24 = dataframe.iloc[-25].squeeze()
        # prépare les données
        count_of_buys = trade.nr_of_successful_entries
        current_time = current_time.astimezone(timezone.utc)
        open_date = trade.open_date.astimezone(timezone.utc)
        dispo = round(self.wallets.get_available_stake_amount())

        limit_buy = 4
        if (count_of_buys < limit_buy) \
                and (last_candle['min288'] == last_candle_24['min288']) \
                and (current_profit < -0.01 * count_of_buys) \
                and (last_candle['close'] < last_candle['mid288']):
            additional_stake = self.config['stake_amount']
            self.log_trade(
                last_candle=last_candle,
                date=current_time,
                action="Loss -",
                dispo=dispo,
                pair=trade.pair,
                rate=current_rate,
                trade_type='Decrease',
                profit=round(current_profit, 4),  # round(current_profit * trade.stake_amount, 2),
                buys=trade.nr_of_successful_entries,
                stake=round(additional_stake, 2)
            )
            return additional_stake
        if (count_of_buys >= limit_buy) & (current_profit < - 0.03 * count_of_buys):
            additional_stake = self.config['stake_amount'] * 2
            self.log_trade(
                last_candle=last_candle,
                date=current_time,
                action="Loss -",
                dispo=dispo,
                pair=trade.pair,
                rate=current_rate,
                trade_type='Decrease',
                profit=round(current_profit, 4),  # round(current_profit * trade.stake_amount, 2),
                buys=trade.nr_of_successful_entries,
                stake=round(additional_stake, 2)
            )
            return additional_stake

        return None

    def calculate_stake(self, pair, last_candle, factor=1):
        amount = self.config['stake_amount'] * factor #1000 / self.first_stack_factor.value self.protection_stake_amount.value  #
        return amount

    def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float, time_in_force: str,
                            current_time: datetime, entry_tag: Optional[str], **kwargs) -> bool:
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        last_candle = dataframe.iloc[-1].squeeze()
        dispo = round(self.wallets.get_available_stake_amount())
        stake_amount = self.calculate_stake(pair, last_candle, 1)

        self.log_trade(
            last_candle=last_candle,
            date=current_time,
            action="START BUY",
            pair=pair,
            rate=rate,
            dispo=dispo,
            profit=0,
            stake=round(stake_amount, 2)
        )
        return True

    def confirm_trade_exit(self, pair: str, trade: Trade, order_type: str, amount: float, rate: float,
                           time_in_force: str,
                           exit_reason: str, current_time, **kwargs) -> bool:

        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        last_candle = dataframe.iloc[-1].squeeze()
        dispo = round(self.wallets.get_available_stake_amount())

        allow_to_sell = (last_candle['percent5'] < -0.00)
        ok = (allow_to_sell) | (exit_reason == 'force_exit')
        if ok:
            # self.pairs[pair]['last_max'] = 0
            # self.pairs[pair]['max_touch'] = 0
            self.pairs[pair]['last_buy'] = 0
            self.pairs[pair]['last_sell'] = rate
            self.log_trade(
                last_candle=last_candle,
                date=current_time,
                action="Sell",
                pair=pair,
                trade_type=exit_reason,
                rate=last_candle['close'],
                dispo=dispo,
                profit=round(trade.calc_profit(rate, amount), 2)
            )
            #print(f"Sell {current_time} {exit_reason} rate={rate:.3f} amount={amount} profit={amount * rate:.3f}")

        return ok

    def custom_exit(self, pair: str, trade: Trade, current_time, current_rate, current_profit, **kwargs):

        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        last_candle = dataframe.iloc[-1].squeeze()

        if (current_profit > 0.004) \
                & (last_candle['hapercent'] < 0.0) \
                & (last_candle['percent'] < 0.0):
            count_of_buys = trade.nr_of_successful_entries
            return 'profit_' + str(count_of_buys)

    def log_trade(self, action, pair, date, trade_type=None, rate=None, dispo=None, profit=None, buys=None, stake=None, last_candle=None):
        # Afficher les colonnes une seule fois
        if self.config.get('runmode') == 'hyperopt':
            return
        if self.columns_logged % 30 == 0:
            print(
                f"| {'Date':<16} | {'Action':<10} | {'Pair':<10} | {'Trade Type':<18} | {'Rate':>12} | {'Dispo':>6} | {'Profit':>8} | {'Pct':>5} | {'max7_1d':>11} | {'max_touch':>12} | {'last_max':>12} | {'Buys':>5} | {'Stake':>10} |"
            )
            print(
                f"|{'-' * 18}|{'-' * 12}|{'-' * 12}|{'-' * 20}|{'-' * 14}|{'-' * 8}|{'-' * 10}|{'-' * 7}|{'-' * 13}|{'-' * 14}|{'-' * 14}|{'-' * 7}|{'-' * 12}|"
            )
            self.columns_logged += 1
        date = str(date)[:16] if date else "-"
        limit = None
        # if buys is not None:
        #     limit = round(last_rate * (1 - self.fibo[buys] / 100), 4)

        rsi = ''
        rsi_pct = ''
        # if last_candle is not None:
        #     if (not np.isnan(last_candle['rsi_1d'])) and (not np.isnan(last_candle['rsi_1h'])):
        #         rsi = str(int(last_candle['rsi_1d'])) + " " + str(int(last_candle['rsi_1h']))
        #     if (not np.isnan(last_candle['rsi_pct_1d'])) and (not np.isnan(last_candle['rsi_pct_1h'])):
        #         rsi_pct = str(int(10000 * last_candle['bb_mid_pct_1d'])) + " " + str(
        #             int(last_candle['rsi_pct_1d'])) + " " + str(int(last_candle['rsi_pct_1h']))

        # first_rate = self.percent_threshold.value
        # last_rate = self.threshold.value
        # action = self.color_line(action, action)
        sma5_1d = ''
        sma5_1h = ''
        # if last_candle['sma5_pct_1d'] is not None:
        #     sma5_1d = round(last_candle['sma5_pct_1d'] * 100, 2)
        # if last_candle['sma5_pct_1h'] is not None:
        #     sma5_1h = round(last_candle['sma5_pct_1h'] * 100, 2)
        sma5 = str(sma5_1d) + ' ' + str(sma5_1h)
        first_rate = self.pairs[pair]['last_max']

        # if action != 'Sell':
        #     profit = round((last_candle['close'] - self.pairs[pair]['last_max']) / self.pairs[pair]['last_max'], 2)

        limit_sell = rsi_pct  # round((last_candle['close'] - self.pairs[pair]['last_max']) / self.pairs[pair]['last_max'], 4)
        max7_1d = round(self.pairs[pair]['max_touch'], 1) #last_candle['max7_1d'] #round(100 * (last_candle['close'] - self.pairs[pair]['last_max']) / self.pairs[pair]['last_max'], 1)
        pct_max = round(100 * (last_candle['close'] - max7_1d) / max7_1d, 1)
        print(
            f"| {date:<16} | {action:<10} | {pair:<10} | {trade_type or '-':<18} | {rate or '-':>12} | {dispo or '-':>6} | {profit or '-':>8} | {pct_max or '-':>5} | {max7_1d or '-':>11} | {round(self.pairs[pair]['max_touch'], 2) or '-':>12} | {round(self.pairs[pair]['last_max'],2) or '-':>12} | {buys or '-':>5} | {stake or '-':>10} |"
        )

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        heikinashi = qtpylib.heikinashi(dataframe)
        dataframe['haopen'] = heikinashi['open']
        dataframe['haclose'] = heikinashi['close']
        dataframe['halow'] = heikinashi['low']
        dataframe['hapercent'] = (dataframe['haclose'] - dataframe['haopen']) / dataframe['haclose']
        dataframe['min12'] = talib.MIN(dataframe['close'], timeperiod=12)
        dataframe['max12'] = talib.MAX(dataframe['close'], timeperiod=12)
        dataframe['min288'] = talib.MIN(dataframe['close'], timeperiod=288)
        dataframe['max288'] = talib.MAX(dataframe['close'], timeperiod=288)
        dataframe['mid288'] = dataframe['min288'] + (dataframe['max288'] - dataframe['min288']) / 2

        dataframe["percent"] = (dataframe["close"] - dataframe["open"]) / dataframe["open"]
        dataframe["percent5"] = dataframe['close'].pct_change(5)

        # 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_diff'] = (dataframe['bb_upperband'] - dataframe['bb_lowerband']) / dataframe['bb_lowerband']

        return dataframe

    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        Buy strategy Hyperopt will build and use.
        """
        # dataframe.loc[
        #     (dataframe['halow'] <= dataframe['min12'])
        #     # & (dataframe['open'] <= dataframe['bb_middleband'])
        #     # & (dataframe['bb_diff'] > 0.01)
        #     ,
        #     'buy']=1
        decalage = 3
        dataframe.loc[
            (dataframe['halow'].shift(decalage) <= dataframe['min288'].shift(decalage))
            & (dataframe['min288'].shift(decalage) == dataframe['min288'])
            # & (dataframe['open'] <= dataframe['bb_middleband'])
            # & (dataframe['bb_diff'] > 0.01)
            ,
            'buy']=1

        return dataframe

    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        Sell strategy Hyperopt will build and use.
        """
        # dataframe.loc[
        #     (qtpylib.crossed_above(dataframe['haclose'], dataframe['haopen'])),
        #     'sell']=1
        return dataframe