"""
Engine class of the RPN Calculator
"""

import math

class rpn_engine:
    def __init__(self):
        """ Constructor """
        self.stack = []

    def push(self, number):
        """ push a value to the internal stack """
        self.stack.append(number)

    def pop(self):
        """ pop a value from the stack """
        try:
            return self.stack.pop()
        except IndexError:
            pass # do not notify any error if the stack is empty...

    def sum_two_numbers(self, op1, op2):
        return op1 + op2

    def subtract_two_numbers(self, op1, op2):
        return op1 - op2

    def multiply_two_numbers(self, op1, op2):
        return op1 * op2

    def divide_two_numbers(self, op1, op2):
        return op1 / op2

    def pow2_a_number(self, op1):
        return op1 * op1

    def sqrt_a_number(self, op1):
        return math.sqrt(op1)


    def compute(self, operation):
        """ compute an operation """

        if operation == '+':
            self.compute_operation_with_two_operands(self.sum_two_numbers)

        if operation == '-':
            self.compute_operation_with_two_operands(self.subtract_two_numbers)

        if operation == '*':
            self.compute_operation_with_two_operands(self.multiply_two_numbers)

        if operation == '/':
            self.compute_operation_with_two_operands(self.divide_two_numbers)

        if operation == '^2':
            self.compute_operation_with_one_operand(self.pow2_a_number)

        if operation == 'SQRT':
            self.compute_operation_with_one_operand(self.sqrt_a_number)

        if operation == 'C':
            self.stack.pop()

        if operation == 'AC':
            self.stack.clear()

    def compute_operation_with_two_operands(self, operation):
        """ exec operations with two operands """
        try:
            if len(self.stack) < 2:
                raise BaseException("Not enough operands on the stack")

            op2 = self.stack.pop()
            op1 = self.stack.pop()
            result = operation(op1, op2)
            self.push(result)
        except BaseException as error:
            print(error)

    def compute_operation_with_one_operand(self, operation):
        """ exec operations with one operand """
        try:
            op1 = self.stack.pop()
            result = operation(op1)
            self.push(result)
        except BaseException as error:
            print(error)