display.py

import pyxel
import time
import numpy as np


# REFACTOR both functions
def isNumber(string):
    if string[0] == "+":
        return False
    try:
        float(string)
        return True
    except ValueError:
        return False


def isPartOfNum(chars):
    """Custom function to detect numbers (or parts of them) on a substring"""
    # print("chars", f"'{chars}'")
    if len(chars) == 0:
        # print("ERROR: This is not a part of a number, it's an empty string")
        return False
    if chars[0] == "-" or chars[0] == ".":
        if len(chars) == 1:
            # Just the sign/period, might be a piece of a number
            return True
        else:
            return isNumber(chars[1:])
    elif chars[:2] == "-.":
        if len(chars) == 2:
            return True
        else:
            return isNumber(chars[2:])
    else:
        return isNumber(chars)


class Display:
    def __init__(self):
        # Chain of current operations
        self.chain = "((3-1)*(2+3))"
        self.pastOperations = []

        # Cursor's position (inverse order, last position is index 0)
        self.index = 0
        # Draws the cursor if its position is changing
        self.prevIndex = self.index
        self.keyCooldown = 0.1
        self.lastPressed = time.time() - self.keyCooldown

        # Text color specifies if the syntax is correct (black) or not (grey)
        self.color = 0

    def addOperation(self, button):
        if button.value == "CE":
            self.clear()
        elif button.value == "=":
            # Container method to perform all calculation related operations
            self.calc()
        elif button.type == "operator":
            # We remove the last operation (if any) and change it for the new one
            pos = len(self.chain) - 1 - self.index
            if self.index == len(self.chain):
                pos = 0
            if pos != -1 and len(self.chain) > 0:
                if (
                    self.chain[pos] == "+"
                    or self.chain[pos] == "-"
                    or self.chain[pos] == "*"
                    or self.chain[pos] == "/"
                ):
                    # There's already an operator, we need to delete it
                    if pos == -1:
                        self.chain = self.chain[:-1]
                    else:
                        self.chain = self.chain[:pos] + self.chain[pos + 1 :]
                # We add an operator, regardless if there was one before or not
                self.__addStr(str(button.value))
            elif len(self.chain) > 0 and button.value == "-" and self.chain[pos] != "-":
                self.__addStr(str(button.value))
        else:
            # Normal character is added
            self.__addStr(str(button.value))
        self.__checkSyntax()

    def calculate(self, result=0):
        if self.__checkSyntax():
            if "(" in self.chain:
                prevChain = self.chain
                # Now, 'self.chain' contains the new subchain detected
                newSubchain, startIndex = self.__findSubChain(self.chain)
                self.chain = newSubchain
                result = self.calculate()
                # A new chain is created with the result of the subchain calculation
                # We delete the parenthesis and add the result
                self.chain = (
                    prevChain[:startIndex]
                    + str(result)
                    + prevChain[startIndex + len(newSubchain) + 2 :]
                )
                print(prevChain, "--->", self.chain)
                # print("Checking on new chain", chain)
                return self.calculate(result=result)
            else:
                # Index of the next operator on the chain (following PEMDAS)
                index = self.__findOperator(self.chain)
                while index != -1:
                    leftNumber, rightNumber = self.__getNumbers(self.chain, index)
                    result = self.__operateNums(
                        float(leftNumber), self.chain[index], float(rightNumber)
                    )
                    print(leftNumber, self.chain[index], rightNumber, "=", result)

                    self.chain = (
                        self.chain[: index - len(leftNumber)]
                        + str(result)
                        + self.chain[index + len(rightNumber) + 1 :]
                    )

                    return self.calculate(result=result)

                if index == -1:
                    result = float(self.chain)
                if isinstance(result, (float, int)) and result.is_integer():
                    return int(result)
                else:
                    return round(float(result), 5)

        else:
            return "Err"

    def __checkSyntax(self):
        """
        Checking if the current operations can be made:
        - No number before/after parenthesis --> Self-corrects
        - No repeated negative signs (--2 --> 2) --> Self-corrects
        - Same number of opening and closing parenthesis
        - At least a digit inside the parenthesis
        - Correct position of decimal points (and no repeted points, 3.1.43)
        - No operator on the first position (expect minus sign)
        - No operators together (expect negative sign)
        - No operator at the end of the string
        """
        self.color = 0
        if len(self.chain) == 0:
            return

        # No repeated negative signs (--2 --> 2) --> Self-corrects
        if len(self.chain) >= 2:
            for i in range(len(self.chain) - 1):
                if self.chain[i] == "-" and self.chain[i + 1] == "-":
                    self.chain = self.chain[:i] + self.chain[i + 2 :]
                    break

        # No number before/after parenthesis --> Self-corrects
        index = 0
        for i in range(self.chain.count("(")):
            index = self.chain.find("(", index + 1)
            if index - 1 >= 0:
                if (
                    self.chain[index - 1] >= "0" and self.chain[index - 1] <= "9"
                ) or self.chain[index - 1] == ")":
                    self.chain = self.chain[:index] + "*" + self.chain[index:]
                    break
        index = 0
        for i in range(self.chain.count(")")):
            index = self.chain.find(")", index + 1)
            if index + 1 < len(self.chain):
                if (
                    self.chain[index + 1] >= "0" and self.chain[index + 1] <= "9"
                ) or self.chain[index + 1] == "(":
                    self.chain = self.chain[: index + 1] + "*" + self.chain[index + 1 :]
                    break

        # Checking for correct pair parenthesis use
        i = 0
        while i < len(self.chain):
            i = self.chain.find("(", i)
            if i == -1:
                break
            if ")" not in self.chain[i:]:
                self.color = 13
                return False
            i += 1
        if self.chain.count("(") != self.chain.count(")"):
            self.color = 13
            return False

        # At least a digit inside the parenthesis: Searching for 'd)', where d is any digit
        i = 0
        while i < len(self.chain):
            i = self.chain.find(")", i)
            if i == -1:
                break
            if i - 1 >= 0:
                if self.chain[i - 1] == ")":
                    # i += 1
                    break
                if not (self.chain[i - 1] >= "0" and self.chain[i - 1] <= "9"):
                    self.color = 13
                    return False
            i += 1

        # Correct decimal points place
        for i in range(len(self.chain) - 1):
            if self.chain[i] == ".":
                # Checking de adjacent characters
                for char in self.chain[i + 1 :]:
                    if char in ("(", ")", "+", "-", "*", "/"):
                        # Finished loop, correct characters
                        break
                    elif char == ".":
                        self.color = 13
                        return False
                for char in self.chain[:i][::-1]:
                    if char in ("(", ")", "+", "-", "*", "/"):
                        # Finished loop, correct characters
                        break
                    elif char == ".":
                        self.color = 13
                        return False

        # No operator on the first place (minus signs can be)
        if len(self.chain) > 0 and self.chain[0] in ("+", "*", "/"):
            self.color = 13
            return False

        # No operators together (expect negative sign)
        index, prevIndex = 0, 0
        for i in range(len(self.chain) - 1):
            if self.chain[i] in ("+", "-", "*", "/"):
                operators = ["+", "-", "*", "/"]
                if self.chain[i] in ("*", "/"):
                    operators = ["+", "*", "/"]

                if self.chain[i + 1] in operators:
                    print("near index", i, self.chain[i], self.chain[i + 1])
                    self.color = 13
                    return False

            prevIndex = index

        # No operator at the end of the string
        if len(self.chain) > 0 and self.chain[-1] in ("*", "/", "+", "-"):
            self.color = 13
            return False

        return True

    def __addStr(self, val):
        """Adds a string 'val' at the position of the cursor"""
        if self.index == 0:
            self.chain += val
            pos = -1
        else:
            pos = len(self.chain) - self.index
            self.chain = self.chain[:pos] + val + self.chain[pos:]

    def calc(self):
        originalChain = self.chain
        result = self.calculate(result=0)
        if result != "Err":
            self.pastOperations.append((originalChain, str(result)))
            print("\nResult:", result)
            self.chain = str(result)
            # Moves the cursor to its corresponding position on the new chain
            self.checkCursor()
        else:
            print("Error trying to calculate", self.chain)

    def __operateNums(self, num1: float, operator, num2: float):
        match operator:
            case "+":
                return num1 + num2
            case "-":
                return num1 - num2
            case "*":
                return num1 * num2
            case "/":
                return num1 / num2
            case _:
                return "Err"

    def __getNumbers(self, chain, index):
        # Parsing left number
        leftStart = 1
        leftNumber = chain[index - leftStart : index]
        while isPartOfNum(leftNumber) and index - leftStart >= 0:
            leftStart += 1
            leftNumber = chain[index - leftStart : index]
        # We need to go back to the previous number (either cause it was out of the string or it no longer was a num)
        leftNumber = chain[index - (leftStart - 1) : index]

        # Parsing right number
        rightEnd = 1
        rightStart = index + 1
        rightNumber = chain[rightStart : rightStart + rightEnd]
        while isPartOfNum(rightNumber) and rightStart + rightEnd <= len(chain):
            rightEnd += 1
            rightNumber = chain[rightStart : rightStart + rightEnd]
        # We need to go back to the previous number (either cause it was out of the string or it no longer was a num)
        rightNumber = chain[rightStart : rightStart + rightEnd - 1]

        return leftNumber, rightNumber

    def __findOperator(self, chain):
        """Finds next operator, following PEMDAS rules"""
        for op in ("*", "/", "+", "-"):
            if op in chain:
                if op == "-":
                    if chain.find(op) != 0:
                        return chain.find(op)
                    else:
                        # Trying to search for another (-) sign (as it's the last obj, it can output -1 or the correct index)
                        return chain.find(op, 1)
                else:
                    return chain.find(op)
        return -1

    def __findSubChain(self, chain):
        # Taking into account we already know there's at least a group of parenthesis
        startIndex = chain.find("(")
        endIndex = chain.find(")", startIndex + 1)
        subchain = chain[startIndex : endIndex + 1]

        # Checking one by one, taking into account there can't be any spare '(' on between (like '((3*2)-3)'
        while subchain.count("(") != subchain.count(")") and endIndex < len(chain):
            endIndex = chain.find(")", endIndex + 1)
            subchain = chain[startIndex : endIndex + 1]

        return chain[startIndex + 1 : endIndex], startIndex

    def draw(self):
        w = len(self.chain) * 4
        x = pyxel.width - 5 - w
        pyxel.text(x, 8, self.chain, self.color)

        # Drawing cursor
        if np.sin(pyxel.frame_count / 4) <= -0.4 or self.index != self.prevIndex:
            cursorX = pyxel.width - 6 - (self.index * 4)
            pyxel.line(cursorX, 6, cursorX, 14, 7)
        self.prevIndex = self.index

        # Drawing the past 3 operations
        y = 16
        operations = self.pastOperations[::-1]
        for operation in operations[:3]:
            opLength = len(operation[0]) + len("=") + len(operation[1])
            x = pyxel.width - opLength * 4 - 6
            pyxel.text(x, y, operation[0] + "=" + operation[1], 4)
            y += 7

    def checkCursor(self):
        # Moving cursor's position
        if (
            pyxel.btn(pyxel.KEY_LEFT)
            and time.time() - self.lastPressed > self.keyCooldown
        ):
            self.prevIndex = self.index
            self.lastPressed = time.time()
            self.index = min(len(self.chain), self.index + 1)
        elif (
            pyxel.btn(pyxel.KEY_RIGHT)
            and time.time() - self.lastPressed > self.keyCooldown
        ):
            self.prevIndex = self.index
            self.lastPressed = time.time()
            self.index = max(0, self.index - 1)
        elif pyxel.btnp(pyxel.KEY_UP):
            # Goes completely to the left
            self.prevIndex = self.index
            self.index = len(self.chain)
        elif pyxel.btnp(pyxel.KEY_DOWN):
            # Goes completely to the right
            self.prevIndex = self.index
            self.index = 0

        # Double checking, in case no key was pressed
        self.index = min(max(0, self.index), len(self.chain))

    def delete(self):
        """Deletes a character at the pointer's position"""
        if self.index == 0:
            self.chain = self.chain[:-1]
        elif self.index != len(self.chain):
            i = len(self.chain) - 1 - self.index
            self.chain = self.chain[:i] + self.chain[i + 1 :]
        self.__checkSyntax()

    def clear(self):
        self.chain = ""
        self.index = 0
        print()

    def __str__(self):
        txt = f"Display: \n Current: {self.chain}\n History:\n "
        for operation in self.pastOperations:
            txt += f"{operation}\n"
        return txt