from bu4.codes import CODE_MAKE, CODE_NULL
from bu4.evaluation.elambda import ELambda
from bu4.linking.afterlinking import AfterLinking
from bu4.linking.allambda import ALLambda
from bu4.parsing.linked import Linked, Parsed, LinkingState
from bu4.linking.linkingfinished import LinkingFinished
from bu4.linking.linkingparsed import LinkingParsed
from bu4.evaluation.aftervalue import envtype, Evaluable

__all__ = ('LLambda', 'PLambda',)


class LLambda(Linked):
    value: Linked

    def __init__(self, promise: set[bytes], name: bytes, value: Parsed):
        assert name not in promise, f'overloaded: {name}'
        self.promise = promise
        self.name = name
        self._value = value

    def link(self) -> LinkingState:
        return AfterLinking(LinkingParsed(self.promise | {self.name}, self._value), ALLambda(self._given_value))

    def _given_value(self, value: Linked) -> LinkingState:
        self.value = value
        self.future = self.value.future - {self.name}
        return LinkingFinished(self)

    def evaluable(self, env: envtype) -> Evaluable:
        return ELambda(
            {name: container for name, container in env.items() if name in self.future},
            self.name,
            self.value
        )

    def __str__(self):
        return f'({self.name.decode()}){self.value}'

    def unlink(self) -> Parsed:
        return PLambda(self.name, self._value)


class PLambda(Parsed):
    def __init__(self, name: bytes, value: Parsed):
        self.name = name
        self.value = value

    def link(self, promise: set[bytes]) -> Linked:
        return LLambda(promise, self.name, self.value)

    def __bytes__(self):
        return bytes([CODE_MAKE, *self.name, CODE_NULL, *bytes(self.value)])