# DExTer : Debugging Experience Tester
# ~~~~~~   ~         ~~         ~   ~~
#
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
"""Conditional Controller Class for DExTer.-"""


import os
import time
from collections import defaultdict
from itertools import chain

from dex.debugger.DebuggerControllers.ControllerHelpers import in_source_file, update_step_watches
from dex.debugger.DebuggerControllers.DebuggerControllerBase import DebuggerControllerBase
from dex.debugger.DebuggerBase import DebuggerBase
from dex.utils.Exceptions import DebuggerException


class ConditionalBpRange:
    """Represents a conditional range of breakpoints within a source file descending from
    one line to another."""

    def __init__(self, expression: str, path: str, range_from: int, range_to: int, values: list):
        self.expression = expression
        self.path = path
        self.range_from = range_from
        self.range_to = range_to
        self.conditional_values = values

    def get_conditional_expression_list(self):
        conditional_list = []
        for value in self.conditional_values:
            # (<expression>) == (<value>)
            conditional_expression = '({}) == ({})'.format(self.expression, value)
            conditional_list.append(conditional_expression)
        return conditional_list


class ConditionalController(DebuggerControllerBase):
    def __init__(self, context, step_collection):
      self.context = context
      self.step_collection = step_collection
      self._conditional_bps = None
      self._watches = set()
      self._step_index = 0
      self._build_conditional_bps()
      self._path_and_line_to_conditional_bp = defaultdict(list)
      self._pause_between_steps = context.options.pause_between_steps
      self._max_steps = context.options.max_steps

    def _build_conditional_bps(self):
        commands = self.step_collection.commands
        self._conditional_bps = []
        try:
            limit_commands = commands['DexLimitSteps']
            for lc in limit_commands:
                conditional_bp = ConditionalBpRange(
                  lc.expression,
                  lc.path,
                  lc.from_line,
                  lc.to_line,
                  lc.values)
                self._conditional_bps.append(conditional_bp)
        except KeyError:
            raise DebuggerException('Missing DexLimitSteps commands, cannot conditionally step.')

    def _set_conditional_bps(self):
        # When we break in the debugger we need a quick and easy way to look up
        # which conditional bp we've breaked on.
        for cbp in self._conditional_bps:
            conditional_bp_list = self._path_and_line_to_conditional_bp[(cbp.path, cbp.range_from)]
            conditional_bp_list.append(cbp)

        # Set break points only on the first line of any conditional range, we'll set
        # more break points for a range when the condition is satisfied.
        for cbp in self._conditional_bps:
            for cond_expr in cbp.get_conditional_expression_list():
                self.debugger.add_conditional_breakpoint(cbp.path, cbp.range_from, cond_expr)

    def _conditional_met(self, cbp):
        for cond_expr in cbp.get_conditional_expression_list():
            valueIR = self.debugger.evaluate_expression(cond_expr)
            if valueIR.type_name == 'bool' and valueIR.value == 'true':
                return True
        return False

    def _run_debugger_custom(self):
        # TODO: Add conditional and unconditional breakpoint support to dbgeng.
        if self.debugger.get_name() == 'dbgeng':
            raise DebuggerException('DexLimitSteps commands are not supported by dbgeng')

        self.step_collection.clear_steps()
        self._set_conditional_bps()

        for command_obj in chain.from_iterable(self.step_collection.commands.values()):
            self._watches.update(command_obj.get_watches())

        self.debugger.launch()
        time.sleep(self._pause_between_steps) 
        while not self.debugger.is_finished:
            while self.debugger.is_running:
                pass

            step_info = self.debugger.get_step_info(self._watches, self._step_index)
            if step_info.current_frame:
                self._step_index += 1
                update_step_watches(step_info, self._watches, self.step_collection.commands)
                self.step_collection.new_step(self.context, step_info)

                loc = step_info.current_location
                conditional_bp_key = (loc.path, loc.lineno)
                if conditional_bp_key in self._path_and_line_to_conditional_bp:

                    conditional_bps = self._path_and_line_to_conditional_bp[conditional_bp_key]
                    for cbp in conditional_bps:
                        if self._conditional_met(cbp):
                            # Unconditional range should ignore first line as that's the
                            # conditional bp we just hit and should be inclusive of final line
                            for line in range(cbp.range_from + 1, cbp.range_to + 1):
                                self.debugger.add_conditional_breakpoint(cbp.path, line, condition='')

            # Clear any uncondtional break points at this loc.
            self.debugger.delete_conditional_breakpoint(file_=loc.path, line=loc.lineno, condition='')
            self.debugger.go()
            time.sleep(self._pause_between_steps)