from ScEpTIC.config.base_config import ScEpTICBaseConfig

from ScEpTIC.emulator.memory.physical.physical_state_retention import PhysicalStateRetention

class StateRetentionConfig(ScEpTICBaseConfig):
    """
    State retention mechanism configuration
    """

    _config_domain = {
        'type': {'class': 'specific', 'values': ['checkpoint', 'task'], 'mode': 'set'},
        'state_save_function_name': {'class': str, 'mode': 'set'},
        'state_restore_function_name': {'class': str, 'mode': 'set'},
        'state_save_strategy': {'class': 'specific', 'values': ['static_placement', 'interrupt'], 'mode': 'set'},
        'state_save_behaviour': {'class': 'specific', 'values': ['probe', 'execute'], 'mode': 'set'},
        'probe_with_adc': {'class': bool, 'mode': 'set'},
        'calculate_v_save_state': {'class': bool, 'mode': 'set'},
        'calculate_v_save_state_additional_cc': {'class': int, 'mode': 'set'},
        'calculate_v_resume_additional_cc': {'class': int, 'mode': 'set'},
        'calculate_v_restore_min_cc': {'class': int, 'mode': 'set'},
        'v_save_state': {'class': float, 'value_check_function': lambda x: x > 0, 'mode': 'set'},
        'v_resume': {'class': float, 'value_check_function': lambda x: x > 0, 'mode': 'set'},
        'hibernate_after_save': {'class': bool, 'mode': 'set'},
        'restore_register_file': {'class': bool, 'mode': 'set'},
        'restore_stack': {'class': bool, 'mode': 'set'},
        'restore_heap': {'class': bool, 'mode': 'set'},
        'restore_volatile_gst': {'class': bool, 'mode': 'set'},
        'restore_non_volatile_gst': {'class': bool, 'mode': 'set'},
        'restore_environment': {'class': bool, 'mode': 'set'},
        'before_restore_function_name': {'class': str, 'mode': 'set'},
        'after_restore_function_name': {'class': str, 'mode': 'set'},
        'before_save_function_name': {'class': str, 'mode': 'set'},
        'after_save_function_name': {'class': str, 'mode': 'set'},
        'physical_state_retention': {'class': PhysicalStateRetention, 'mode': 'set'},
    }

    _function_names = [
        'state_save_function_name',
        'state_restore_function_name',
        'before_restore_function_name',
        'after_restore_function_name',
        'before_save_function_name',
        'after_save_function_name',
    ]

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

        self.type = 'checkpoint'

        # Routines
        self.state_save_function_name    = f"{self._main_config.program.ir_function_prefix}checkpoint"
        self.state_restore_function_name = f"{self._main_config.program.ir_function_prefix}restore"

        # Custom routines executed before/after state-saving/stare-restoring operations
        self.before_save_function_name    = f"{self._main_config.program.ir_function_prefix}sceptic_before_save"
        self.after_save_function_name     = f"{self._main_config.program.ir_function_prefix}sceptic_after_save"
        self.before_restore_function_name = f"{self._main_config.program.ir_function_prefix}sceptic_before_restore"
        self.after_restore_function_name  = f"{self._main_config.program.ir_function_prefix}sceptic_after_restore"

        # Placement
        self.state_save_strategy = 'static'
        self.state_save_behaviour = 'execute'

        # Restore config
        self.restore_register_file = True
        self.restore_stack = True
        self.restore_heap = True
        self.restore_volatile_gst = True
        self.restore_non_volatile_gst = False
        self.restore_environment = False
        self.hibernate_after_save = False

        # Voltage threshold for probe / interrupts
        self.calculate_v_save_state = False
        self.calculate_v_save_state_additional_cc = 0
        self.calculate_v_resume_additional_cc = 0
        self.calculate_v_restore_min_cc = 0
        self.probe_with_adc = False
        self.v_save_state = 0.0
        self.v_resume = 0.0

        # Physical state retention
        self.physical_state_retention = None

        for name in self._function_names:
            self._register_config_callback(name, self._append_prefix_callback)


    def _append_prefix_callback(self, config_name, config_value):
        """
        Callback to append prefix to state save/restore functions
        :param config_name: the configuration name
        :param config_value: the configuration value
        """
        prefix = self._main_config.program.ir_function_prefix

        for attribute in self._function_names:
            attribute_val = getattr(self, attribute)
            if attribute_val[0] != prefix:
                setattr(self, attribute, f"{prefix}{attribute_val}")