from binance.enums import *
import yaml

from Signals import Signals
from indicators import Indicators


class Configuration:
    def __init__(self):
        # ************** Default values**************

        # The title of our program.
        self.application_title = 'BrighterTrades'

        # The maximum number of candles to store in memory.
        self.max_data_loaded = 1000

        # The default values for the main chart.
        self.chart_interval = KLINE_INTERVAL_15MINUTE
        self.trading_pair = 'BTCUSDT'

        # The name of the file that stores saved_data
        self.config_FN = 'config.yml'

        # Call a static method from indicators that fills in a default list of indicators in config.
        self.indicator_list = Indicators.get_indicator_defaults()

        # Call a static method from indicators that fills in a default list of indicators in config.
        self.signals_list = Signals.get_signals_defaults()

        # list of strategies in config.
        self.strategies_list = []

        # list of trades.
        self.trades = []

        # The data that will be saved and loaded from file .
        self.saved_data = None

        # Load any saved data from file
        self.config_and_states('load')

    def update_data(self, data_type, data):
        # Replace current list of data sets with an updated list.
        if data_type == 'strategies':
            self.strategies_list = data
        elif data_type == 'signals':
            self.signals_list = data
        elif data_type == 'trades':
            self.trades = data
        else:
            raise ValueError(f'Configuration: update_data(): Unsupported data_type: {data_type}')
        # Save it to file.
        self.config_and_states('save')

    def remove(self, what, name):
        # Removes by name an item from a list in saved data.
        print(f'removing {what}:{name}')
        for obj in self.saved_data[what]:
            if obj['name'] == name:
                self.saved_data[what].remove(obj)
                break
        # Save it to file.
        self.config_and_states('save')

    def set_chart_interval(self, interval):
        self.chart_interval = interval

    def set_trading_pair(self, symbol):
        self.trading_pair = symbol

    def config_and_states(self, cmd):
        """Loads or saves configurable data to the file set in self.config_FN"""

        # The data stored and retrieved from file session.
        self.saved_data = {
            'indicator_list': self.indicator_list,
            'config': {'chart_interval': self.chart_interval, 'trading_pair': self.trading_pair},
            'signals': self.signals_list,
            'strategies': self.strategies_list,
            'trades': self.trades
        }

        def set_loaded_values():
            # Sets the values in the saved_data object.
            if 'indicator_list' in self.saved_data:
                self.indicator_list = self.saved_data['indicator_list']

            if 'chart_interval' in self.saved_data['config']:
                self.chart_interval = self.saved_data['config']['chart_interval']

            if 'trading_pair' in self.saved_data['config']:
                self.trading_pair = self.saved_data['config']['trading_pair']

            if 'signals' in self.saved_data:
                self.signals_list = self.saved_data['signals']

            if 'strategies' in self.saved_data:
                self.strategies_list = self.saved_data['strategies']

            if 'trades' in self.saved_data:
                self.trades = self.saved_data['trades']

        def load_configuration(filepath):
            """load file data"""
            with open(filepath, "r") as file_descriptor:
                data = yaml.safe_load(file_descriptor)
            return data

        def save_configuration(filepath, data):
            """Saves file data"""
            with open(filepath, "w") as file_descriptor:
                yaml.dump(data, file_descriptor)

        if cmd == 'load':
            # If load_configuration() finds a file it overwrites
            # the saved_data object otherwise it creates a new file
            # with the defaults contained in saved_data>

            # If file exist load the values.
            try:
                self.saved_data = load_configuration(self.config_FN)
                set_loaded_values()
            # If file doesn't exist create a file and save the default values.
            except IOError:
                save_configuration(self.config_FN, self.saved_data)

        elif cmd == 'save':
            try:
                # Write saved_data to the file.
                save_configuration(self.config_FN, self.saved_data)
            except IOError:
                raise ValueError("save_configuration(): Couldn't save the file.")
        else:
            raise ValueError('save_configuration(): Invalid command received.')