#  Copyright (c) PARRRATE T&V 2021. All rights reserved.

from bu4.evaluation.av.aftervalue import AfterValue
from bu4.evaluation.av.envtype import envtype
from bu4.evaluation.constructs.elinked import ELinked
from bu4.evaluation.constructs.evaluable import Evaluable
from bu4.evaluation.targets.avcall import AVCall
from bu4.linking.states.afterlinking import AfterLinking
from bu4.linking.states.linkingfinished import LinkingFinished
from bu4.linking.states.linkingparsed import LinkingParsed
from bu4.linking.states.linkingstate import LinkingState
from bu4.linking.targets.allambda import ALLambda
from bu4.parsing.constructs.linked import Linked, Parsed

__all__ = ('PCall',)


class LCall(Linked):
    argument: Linked
    lambda_: Linked

    def __init__(self, promise: set[bytes], argument: Parsed, lambda_: Parsed):
        self.promise = promise
        self._argument = argument
        self._lambda = lambda_

    def link(self) -> LinkingState:
        return AfterLinking(
            LinkingParsed(self.promise, self._argument),
            ALLambda(self._given_argument)
        )

    def _given_argument(self, argument: Linked) -> LinkingState:
        self.argument = argument
        return AfterLinking(
            LinkingParsed(self.promise, self._lambda),
            ALLambda(self._given_lambda)
        )

    def _given_lambda(self, lambda_) -> LinkingState:
        self.lambda_ = lambda_
        self.future = self.argument.future | self.lambda_.future
        return LinkingFinished(self)

    def evaluable(self, env: envtype) -> Evaluable:
        return AfterValue(ELinked(env, self.lambda_), AVCall(env, self.argument))

    def __str__(self):
        return f'/{self.argument}{self.lambda_}'

    def unlink(self) -> Parsed:
        return PCall(self._argument, self._lambda)


class PCall(Parsed):
    def __init__(self, argument: Parsed, lambda_: Parsed):
        self.argument = argument
        self.lambda_ = lambda_

    def link(self, promise: set[bytes]) -> Linked:
        return LCall(promise, self.argument, self.lambda_)