"""
Contains the placeholder for types for use in Phasm.

These are temporary while the compiler is calculating all the types and validating them.
"""
from typing import Any, Iterable, List, Optional, Protocol, Union

from .types import Type3

TYPE3_ASSERTION_ERROR = 'You must call phasm_type3 after calling phasm_parse before you can call any other method'

class ExpressionProtocol(Protocol):
    """
    A protocol for classes that should be updated on substitution
    """

    type3: 'Type3OrPlaceholder'
    """
    The type to update
    """

class PlaceholderForType:
    """
    A placeholder type, for when we don't know the final type yet
    """
    __slots__ = ('update_on_substitution', 'resolve_as', )

    update_on_substitution: List[ExpressionProtocol]
    resolve_as: Optional[Type3]

    def __init__(self, update_on_substitution: Iterable[ExpressionProtocol]) -> None:
        self.update_on_substitution = [*update_on_substitution]
        self.resolve_as = None

    def __repr__(self) -> str:
        uos = ', '.join(repr(x) for x in self.update_on_substitution)

        return f'PlaceholderForType({id(self)}, [{uos}])'

    def __str__(self) -> str:
        return f'PhFT_{id(self)}'

    def __format__(self, format_spec: str) -> str:
        if format_spec != 's':
            raise TypeError('unsupported format string passed to Type3.__format__')

        return str(self)

    def __eq__(self, other: Any) -> bool:
        if isinstance(other, Type3):
            return False

        if not isinstance(other, PlaceholderForType):
            raise NotImplementedError

        return self is other

    def __ne__(self, other: Any) -> bool:
        return not self.__eq__(other)

    def __hash__(self) -> int:
        return 0 # Valid but performs badly

    def __bool__(self) -> bool:
        raise NotImplementedError

Type3OrPlaceholder = Union[Type3, PlaceholderForType]