from tclint.syntax_tree import Visitor, Command, BareWord, List
import lsprotocol.types as lsp
from common.load_data import standard_items


class CompletionItems:
    def __init__(self):
        self._custom_functions: list[lsp.CompletionItem] = []

    @property
    def custom_functions(self) -> list[lsp.CompletionItem]:
        return self._custom_functions

    @custom_functions.setter
    def custom_functions(self, value: lsp.CompletionItem):
        self._custom_functions.append(value)


class _Completion(Visitor):
    def __init__(self):
        super().__init__()
        self._custom_functions: list[lsp.CompletionItem] = []
        self._proc_signatures = {}

    @property
    def custom_functions(self) -> list[lsp.CompletionItem]:
        return self._custom_functions

    @property
    def proc_signatures(self):
        return self._proc_signatures

    def reset(self):
        self._custom_functions = []
        self._proc_signatures = {}

    def visit_command(self, command: Command):
        routine = command.routine

        if routine.contents == "proc" and command.args:
            first_arg = command.args[0]
            if not first_arg.value:
                return

            if any(item.label == first_arg.value for item in standard_items.nx_procs):
                return

            try:
                self._custom_functions.remove(first_arg.value)
            except ValueError:
                pass

            self._custom_functions.append(lsp.CompletionItem(label=first_arg.value, kind=lsp.CompletionItemKind.Function))
            if len(command.args) < 2:
                return

            param_list_node = command.args[1]
            if not hasattr(param_list_node, "children"):
                return

            param_names = []
            for arg in param_list_node.children:
                if isinstance(arg, BareWord):
                    param_names.append(arg.value)
                elif isinstance(arg, List) and len(arg.children) >= 1:
                    first = arg.children[0]
                    if isinstance(first, BareWord):
                        param_names.append(first.value)

            self._proc_signatures[first_arg.value] = param_names


def remove_existing_items(items: list[lsp.CompletionItem], store: dict) -> None:
    """
    Entfernt alle CompletionItems aus dem store, deren label in der items-Liste vorkommt.
    Änderungen erfolgen in-place.
    """
    labels_to_remove = {item.label for item in items}

    for key in list(store.keys()):
        filtered = [ci for ci in store[key] if ci.label not in labels_to_remove]
        if filtered:
            store[key] = filtered
        else:
            del store[key]


def remove_shared_keys(nested_dict: dict[str, dict[str, list]], flat_dict: dict[str, list]) -> None:
    """
    Entfernt alle Keys aus nested_dict[file][func], wenn func auch in flat_dict vorhanden ist.
    Änderungen erfolgen in-place.
    """
    for file_path, func_dict in list(nested_dict.items()):
        for func_name in list(func_dict.keys()):
            if func_name in flat_dict:
                del nested_dict[file_path][func_name]

        if not nested_dict[file_path]:
            del nested_dict[file_path]


completion = _Completion()