from .message import message
from .message_builder import message_builder
from .message_step_builder import message_step_builder
from .protocol import protocol

class decoder(protocol):
    def __init__(self, content: str) -> None:
        self.__content = content
        self.__builder = message_step_builder()

    def process(self) -> object:
        if self.__content is None:
            return self

        for line in self._lines:
            self.__parse_line(line)

        self.__content = None
        return self

    def result(self, message_type: type | None = None) -> message:
        if self.__content is not None:
            self.process()
        
        if message_type is None:
            return self._builder.build()

        return message_type(self._builder.build())

    @property
    def _lines(self) -> str:
        return self.__content.split(self._line_separator)
    
    @property 
    def _builder(self) -> message_step_builder:
        return self.__builder

    def __parse_line(self, line: str) -> None:
        line = line.strip()

        if self.__is_section(line):
            self.__parse_section(line)
            return

        self.__parse_key_value(line)

    def __is_section(self, line: str) -> bool:
        if len(line) < 1:
            return False

        return line[0] == self._section_buckles[0]

    def __parse_key_value(self, line: str) -> None:
        position = line.find("=")
        
        if position == -1:    
            return

        key = line[:position].strip()
        position = position + 1
        value = line[position:].strip()

        self._builder.add(key, value)

    def __parse_section(self, line: str) -> None:
        for char in self._section_buckles:
            line = line.replace(char, "")
        
        self._builder.change_section(line)