table_manager.py

from typing import Optional


class TableManager:
    def __init__(self):
        self.keywords_table = {}
        self.operators_table = {}
        self.identifiers_table = {}
        # {name: {'index': int, 'described': bool, 'type': str}}
        self.constants_table = {}  # {value: index} - простая структура для констант
        self.addresses_table = {}  # {name: index} - таблица адресов для ПОЛИЗа
        self.address_to_name = (
            {}
        )  # {index: name} - обратное отображение для поиска по индексу

        self.keywords_tree = None
        self.operators_tree = None
        self.identifiers_tree = None
        self.constants_tree = None

        self.initialize_tables()

    def set_treeviews(
        self, keywords_tree, operators_tree, identifiers_tree, constants_tree
    ):
        self.keywords_tree = keywords_tree
        self.operators_tree = operators_tree
        self.identifiers_tree = identifiers_tree
        self.constants_tree = constants_tree
        self.update_tables_display()

    def initialize_tables(self):
        keywords = [
            "dim",
            "integer",
            "real",
            "boolean",
            "as",
            "if",
            "then",
            "else",
            "for",
            "to",
            "do",
            "while",
            "read",
            "write",
            "or",
            "and",
            "not",
            "true",
            "false",
        ]
        for i, keyword in enumerate(keywords, 1):
            self.keywords_table[keyword] = i

        operators = [
            ">",
            "=",
            "<",
            "<=",
            ">=",
            "<>",
            "+",
            "-",
            "or",
            "*",
            "/",
            "and",
            "(",
            ")",
            "[",
            "]",
            "{",
            "}",
            ",",
            ";",
            ":",
            ":=",
            ".",
            "not",
        ]
        for i, operator in enumerate(operators, 1):
            self.operators_table[operator] = i

    def add_identifier(self, name):
        """Добавить идентификатор в таблицу"""
        if name not in self.identifiers_table:
            index = len(self.identifiers_table) + 1
            self.identifiers_table[name] = {
                "index": index,
                "described": False,
                "type": None,
            }
            return index
        return self.identifiers_table[name]["index"]

    def add_constant(self, value):
        """Добавить константу в таблицу"""
        if value not in self.constants_table:
            index = len(self.constants_table) + 1
            self.constants_table[value] = index
        return self.constants_table[value]

    def set_identifier_info(self, name, described=None, type=None):
        """Установить информацию об идентификаторе"""
        if name in self.identifiers_table:
            if described is not None:
                self.identifiers_table[name]["described"] = described
            if type is not None:
                self.identifiers_table[name]["type"] = type

    def get_identifier_info(self, name):
        """Получить информацию об идентификаторе"""
        return self.identifiers_table.get(name)

    def update_identifier_table_display(self):
        """Обновляет отображение таблицы идентификаторов с семантической информацией"""
        if self.identifiers_tree:
            self.identifiers_tree.delete(*self.identifiers_tree.get_children())

            # Обновляем колонки для таблицы идентификаторов
            columns = ("№", "Лексема", "Описан", "Тип", "Код")
            self.identifiers_tree.configure(columns=columns)

            # Устанавливаем заголовки
            self.identifiers_tree.heading("№", text="№")
            self.identifiers_tree.heading("Лексема", text="Лексема")
            self.identifiers_tree.heading("Описан", text="Описан")
            self.identifiers_tree.heading("Тип", text="Тип")
            self.identifiers_tree.heading("Код", text="Код")

            # Устанавливаем ширины колонок
            self.identifiers_tree.column("№", width=50)
            self.identifiers_tree.column("Лексема", width=150)
            self.identifiers_tree.column("Описан", width=80)
            self.identifiers_tree.column("Тип", width=100)
            self.identifiers_tree.column("Код", width=80)

            # Заполняем данные
            for name, info in self.identifiers_table.items():
                described = "Да" if info["described"] else "Нет"
                type_str = info["type"] if info["type"] else "—"
                self.identifiers_tree.insert(
                    "",
                    "end",
                    values=(
                        info["index"],
                        name,
                        described,
                        type_str,
                        f"(4,{info['index']})",
                    ),
                )

    def update_tables_display(self):
        if self.keywords_tree:
            self.keywords_tree.delete(*self.keywords_tree.get_children())
            for keyword, code in self.keywords_table.items():
                self.keywords_tree.insert(
                    "", "end", values=(code, keyword, f"(1,{code})")
                )

        if self.operators_tree:
            self.operators_tree.delete(*self.operators_tree.get_children())
            for operator, code in self.operators_table.items():
                self.operators_tree.insert(
                    "", "end", values=(code, operator, f"(2,{code})")
                )

        if self.constants_tree:
            self.constants_tree.delete(*self.constants_tree.get_children())
            for constant, index in self.constants_table.items():
                self.constants_tree.insert(
                    "", "end", values=(index, constant, f"(3,{index})")
                )

        # Используем новый метод для идентификаторов
        self.update_identifier_table_display()

    def clear_dynamic_tables(self):
        self.identifiers_table.clear()
        self.constants_table.clear()
        self.addresses_table.clear()
        self.address_to_name.clear()
        self.update_tables_display()

    def add_address(self, identifier_name: str) -> int:
        """Добавить адрес переменной в таблицу адресов"""
        if identifier_name not in self.addresses_table:
            info = self.get_identifier_info(identifier_name)
            if info:
                index = info["index"]
                self.addresses_table[identifier_name] = index
                self.address_to_name[index] = identifier_name
                return index
            else:
                # Если идентификатора нет, создаем временную запись
                index = len(self.addresses_table) + 1
                self.addresses_table[identifier_name] = index
                self.address_to_name[index] = identifier_name
                return index
        return self.addresses_table[identifier_name]

    def get_address_index(self, identifier_name: str) -> int:
        """Получить индекс адреса переменной"""
        return self.addresses_table.get(identifier_name, 0)

    def get_address_name(self, index: int) -> Optional[str]:
        """Получить имя переменной по индексу адреса"""
        return self.address_to_name.get(index)

    def get_address_info(self, address_index: int) -> Optional[dict]:
        """Получает информацию о переменной по индексу адреса"""
        # Ищем имя переменной по адресу
        var_name = self.get_address_name(address_index)
        if var_name and var_name in self.identifiers_table:
            info = self.identifiers_table[var_name].copy()
            info["name"] = var_name
            info["index"] = address_index
            return info
        
        # Если не нашли по имени, ищем в таблице идентификаторов по индексу
        for name, info in self.identifiers_table.items():
            if info["index"] == address_index:
                result = info.copy()
                result["name"] = name
                result["index"] = address_index
                return result
        
        return None

    def get_identifier_by_index(self, index: int) -> Optional[str]:
        """Получить имя идентификатора по его индексу"""
        for name, info in self.identifiers_table.items():
            if info["index"] == index:
                return name
        return None

    def get_constant_by_index(self, index: int) -> Optional[str]:
        """Получить значение константы по её индексу"""
        for const, idx in self.constants_table.items():
            if idx == index:
                return const
        return None