import types
import functools

from .message import message
from .protocol import protocol
from .string_builder import string_builder

class encoder(protocol):
    def __init__(self, target: message) -> None:
        self.__target = target

    @property
    def _target(self) -> message:
        return self.__target

    @functools.cache
    def process(self) -> str:
        result = string_builder()
        result.add(self.__code_section_body(self._target.default))

        for section, content in self._target.sections.items():
            result.add(self.__code_section_header(section))
            result.add(self.__code_section_body(content))

        return result.build()

    def __code_section_body(self, content: dict) -> str:
        result = string_builder()
        
        for key, value in content.items():
            result.add(self.__code_key_value(key, value))

        return result.build()

    def __code_section_header(self, section: str) -> str:
        return string_builder() \
        .add(self._section_buckles[0]) \
        .add(section) \
        .add(self._section_buckles[1]) \
        .add(self._line_separator) \
        .build()
    
    def __code_key_value(self, key: str, value: str) -> str:
        return string_builder() \
        .add(key) \
        .add(self._setter) \
        .add(value) \
        .add(self._line_separator) \
        .build()

    def __str__(self) -> str:
        return self.process()

    def __repr(self) -> str:
        return "Message encoder:\n" + str(self)