import abc
from typing import Any, Optional, List, Dict, Union, Generic, Callable, NoReturn, Set, Iterable, TypeVar

from . import *

_RUNTIME_COMPILE = False

S = TypeVar('S', bound='Scope')


class Scope(metaclass=abc.ABCMeta):
    """variable lookup scope.

    """

    __slots__ = ('__parent',)

    def __init__(self):
        self.__parent: Optional[Scope] = None

    def __contains__(self, item: str) -> bool:
        """has variable defined?"""
        scope = self

        while scope is not None:
            if scope.contain_local(item):
                return True
            else:
                scope = scope.__parent

        return False

    def __getitem__(self, item: str) -> Any:
        """get variable through the scope chain."""
        scope = self

        while scope is not None:
            if scope.contain_local(item):
                return scope.get_local(item)
            else:
                scope = scope.__parent

        raise KeyError(item)

    def __setitem__(self, key: str, value: Any):
        """set variable to the scope which define it."""
        scope = self

        while scope is not None:
            if scope.contain_local(key):
                return scope.set_local(key, value)
            else:
                scope = scope.__parent

        self.set_local(key, value)

    def __delitem__(self, key: str):
        """delete variable from the scope which define it"""
        scope = self

        while scope is not None:
            if scope.contain_local(key):
                return scope.del_local(key)
            else:
                scope = scope.__parent

        raise KeyError(key)

    @abc.abstractmethod
    def locals(self) -> Iterable[str]:
        """variable key defined in this scope"""
        pass

    def globals(self) -> Set[str]:
        """variable key existed in this scope"""
        if self.__parent is not None:
            ret = self.__parent.globals()
        else:
            ret = set()

        ret.update(self.locals())

        return ret

    @abc.abstractmethod
    def contain_local(self, key: str) -> bool:
        """has variable in current scope?"""
        pass

    @abc.abstractmethod
    def get_local(self, key: str) -> Any:
        """get variable from this scope"""
        pass

    @abc.abstractmethod
    def set_local(self, key: str, value: Any):
        """set variable to this scope."""
        pass

    @abc.abstractmethod
    def del_local(self, key: str):
        """remove variable from this scope"""
        pass

    @abc.abstractmethod
    def clear(self):
        """clear all variable define in this scope."""
        pass

    def child(self, **local) -> 'Scope':
        """new a child scope with variable *local*"""
        ret = ContextScope()
        ret.__parent = self

        for k, v in local.items():
            ret.set_local(k, v)

        return ret

    def chain(self, scope: S) -> S:
        scope.__parent = self

        return scope

    def wrap(self, scope: 'Scope') -> 'Scope':
        ret = WrapScope(scope)
        ret.__parent = self

        return ret

    def eval(self, expression: str) -> Any:
        # Internal instruction are only handled with a simple form in the ListInstruction,
        # so if a internal instruction is put in the deep expression, scope doesn't know how to
        # evaluate it. Actually, we can not evaluate internal instruction here, because this eval()
        # function is proposed to evaluate nothing but a value, not a function call,
        # we just return the expression itself.
        if expression.startswith('_') and '(' in expression and expression.endswith(')'):
            return expression

        try:
            # noinspection PyTypeChecker
            return eval(expression, {}, self)
        except BaseException as e:
            raise RuntimeError(expression) from e

    def __str__(self):
        if self.__parent is None:
            return ' > {}'
        else:
            return ' > ' + str(self.__parent)

    __repr__ = __str__


class ContextScope(Scope):
    """General scope implement."""

    __slots__ = ('_context',)

    def __init__(self, init: Optional[Dict[str, Any]] = None):
        super().__init__()

        self._context: Dict[str, Any] = {}

        if init is not None:
            self._context.update(init)

    def locals(self) -> Iterable[str]:
        return self._context.keys()

    def contain_local(self, key: str) -> bool:
        return key in self._context

    def get_local(self, key: str):
        return self._context[key]

    def set_local(self, key: str, value: Any):
        self._context[key] = value

    def del_local(self, key: str):
        del self._context[key]

    def clear(self):
        self._context.clear()

    def __str__(self):
        return str(self._context) + super().__str__()


class ConstantScope(Scope):
    """constant scope, which cannot update, removed the variable defined in this scope after initialized."""
    EMPTY: 'ConstantScope' = None

    __slots__ = ('_constant',)

    def __init__(self, constant: Dict[str, Any]):
        super().__init__()

        self._constant = dict(constant)

    def locals(self) -> Iterable[str]:
        return self._constant.keys()

    def contain_local(self, key: str) -> bool:
        return key in self._constant

    def get_local(self, key: str):
        return self._constant[key]

    def set_local(self, key: str, value: Any):
        """do nothing"""
        pass

    def del_local(self, key: str):
        """do nothing"""
        pass

    def clear(self):
        """do nothing"""
        pass

    def __str__(self):
        return 'constant:' + str(self._constant) + super().__str__()



class ReadonlyScope(Scope, metaclass=abc.ABCMeta):
    """readonly scope"""

    __slots__ = ('_variable',)

    def __init__(self, variable: Iterable[str]):
        super().__init__()

        self._variable = list(variable)

    def locals(self) -> Dict[str, Any]:
        return {p: self.get_local(p) for p in self._variable}

    def contain_local(self, key: str) -> bool:
        return key in self._variable

    @abc.abstractmethod
    def get_local(self, key: str) -> Any:
        pass

    def set_local(self, key: str, value: Any):
        """variable in this scope are read-only. do nothing"""
        pass

    def del_local(self, key: str):
        """variable in this scope are read-only. do nothing"""
        pass

    def clear(self):
        """variable in this scope are read-only. do nothing"""
        pass

    def __str__(self):
        return self.__class__.__name__ + ':' + str(self._variable) + super().__str__()



ConstantScope.EMPTY = ConstantScope({})


class WrapScope(Scope):
    __slots__ = ('_scope',)

    def __init__(self, scope: Scope):
        super().__init__()
        self._scope = scope

    def locals(self) -> Iterable[str]:
        return self._scope.locals()

    def contain_local(self, key: str) -> bool:
        return self._scope.contain_local(key)

    def get_local(self, key: str) -> Any:
        return self._scope.get_local(key)

    def set_local(self, key: str, value: Any):
        self._scope.set_local(key, value)

    def del_local(self, key: str):
        self._scope.del_local(key)

    def clear(self):
        self._scope.clear()

    def __getattr__(self, item):
        return getattr(self._scope, item)

    def __str__(self):
        return str(self._scope) + super().__str__()



class Expression(Generic[T], JsonSerialize, metaclass=abc.ABCMeta):
    """
    **json format**

    ::

        Expression[T]
            # constant value
            = ConstantExpression[T]     # type: null, bool, int, float
            | ArrayExpression[T]        # type: list
            # dynamic value
            | ComplexExpression[T]      # type: str, dict

    **variable scope search chain**

    1.  parent scope

    """

    __slots__ = ()

    @abc.abstractmethod
    def value(self, context: Scope) -> T:
        """eval expression under scope *context* and get a value."""
        pass

    def value_local(self, context: Scope, **variable) -> T:
        """eval expression under scope *context* with some local variable and get a value."""
        return self.value(context.child(**variable))

    @abc.abstractmethod
    def as_json(self):
        pass

    @classmethod
    def parse(cls, json: Optional[JSON]) -> 'Expression':
        if json is None:
            return NullConstant

        elif json is True:
            return TrueConstant

        elif json is False:
            return FalseConstant

        elif isinstance(json, (int, float)):
            return ConstantExpression(json)

        elif isinstance(json, str):
            return ComplexExpression(json)

        elif isinstance(json, list):
            return ArrayExpression.parse(json)

        elif isinstance(json, dict):
            return ComplexExpression.parse(json)

        else:
            raise RuntimeError('illegal value : ' + _truncate(json))


class ConstantExpression(Expression[T]):
    """expression with constant value.

    **json format**

    ::

        ConstantExpression[T]
            = null
            | int
            | bool
            | int
            | float

    """

    __slots__ = ('_constant',)

    def __init__(self, constant: T):
        self._constant = constant

    @property
    def constant(self) -> T:
        return self._constant

    def value(self, context: Scope) -> T:
        return self._constant

    def as_json(self):
        return self._constant

    def __hash__(self):
        return hash(self._constant) + 17

    def __eq__(self, other):
        if isinstance(other, ConstantExpression):
            return self._constant == other._constant
        else:
            return self._constant == other

    def __str__(self):
        return str(self._constant)

    def __repr__(self):
        return repr(self._constant)


NullConstant = ConstantExpression(None)
TrueConstant = ConstantExpression(True)
FalseConstant = ConstantExpression(False)


class ArrayExpression(Expression[T]):
    """array expression.

    **json format**

    ::

        ArrayExpression[T]
            = [T]

    """
    __slots__ = ('_content',)

    def __init__(self, content: List[T]):
        self._content = content

    def __len__(self):
        return len(self._content)

    def __getitem__(self, index: int) -> T:
        return self._content[index]

    def __iter__(self):
        return iter(self._content)

    def value(self, context: Scope) -> List[T]:
        return self._content

    def as_json(self):
        return self._content

    @classmethod
    def parse(cls, json: JSON_ARRAY) -> 'ArrayExpression':
        return ArrayExpression(json)


class UndeterminedExpression(Expression[T]):
    """json object for undetermined expression

    """
    __slots__ = ('_json',)

    def __init__(self, json: JSON_OBJECT):
        self._json = json

    def value(self, context) -> NoReturn:
        raise RuntimeError('undetermined expression : ' + _truncate(self._json))

    def as_json(self):
        return self._json


class ComplexExpression(Expression[T]):
    """
    **json format**

    ::

        ComplexExpression[T]
            = UndeterminedExpression
            | ComplexExpression[T]
            | BoolExpression[T]
            | ListExpression[T]
            | WhenExpression[T]
            | GuardExpression

        ComplexExpression[T] = {
            "expression" :str = expression
            "dependency"? : str|[str]
        }

    **variable scope search chain**

    *   for value evaluation

        1.  parent scope

    *   for children expression evaluation

        1.  parent scope
        #.  {VALUE=eval result}


    """

    __slots__ = ('expression', 'dependency')

    def __init__(self, expression: str, dependency: List[str] = None):
        self.expression: str = expression
        self.dependency = dependency if dependency is not None else []

    def value(self, context: Scope) -> T:
        return context.eval(self.expression)

    def travel(self, traveler: 'ExpressionTraveler'):
        traveler.on_node(self)

    def node_keys(self) -> List[str]:
        """iterator the keys of the children nodes"""
        return []

    def get_node(self, key: str) -> Optional[Expression[T]]:
        """get child node with **key**"""
        raise AttributeError('expression %s does not have %s node' % (type(self), key))

    def set_node(self, key: str, node: Optional[Expression[T]]):
        """replace child node **key** with **node**"""
        raise AttributeError('expression %s does not have %s node' % (type(self), key))

    def as_json(self):
        ret = {
            'expression': self.expression,
        }

        if len(self.dependency) > 0:
            ret['dependency'] = self.dependency

        return ret

    @classmethod
    def parse(cls, json: JSON_OBJECT) -> Union['ComplexExpression', UndeterminedExpression]:
        expression = _get(json, 'expression', str, _truncate(json), nullable=True)

        if expression is None:
            # un-determined expression
            return UndeterminedExpression(json)

        if 'when' in json:
            return WhenExpression.parse(json)

        elif 'list' in json:
            return ListExpression.parse(json)

        elif 'raise' in json:
            return GuardExpression.parse(json)

        elif 'true' in json or 'false' in json or 'else' in json:
            return BoolExpression.parse(json)

        else:
            # only contain expression

            dep = _get(json, 'dependency', (str, list), 'expression', nullable=True)
            if dep is not None:
                if isinstance(dep, str):
                    dep = [dep]
                else:
                    dep = list(map(str, dep))

            return ComplexExpression(expression, dep)


class ExpressionTraveler:
    __slots__ = ('__on_node', '__on_enter', '__on_exit',
                 '__current_expr', '__current_key')

    def __init__(self,
                 on_node: Callable[[Optional[ComplexExpression], Optional[str], Optional[Expression]], None],
                 on_enter: Callable[[ComplexExpression], bool] = None,
                 on_exit: Callable[[ComplexExpression], None] = None):
        """Expression tree traveler.

        **on_node** function type : ``(parent_expr?, node_name?, node) -> None``. callable when goto this expression.

        **on_enter** function_type: ``(expr) -> bool``. callable when this expression is :class:`ComplexExpression`
        and prepare to enter this.The return result decide whether enter this expression or not.

        **on_exit** function_type: ``(expr) -> None``. callable when this expression is :class:`ComplexExpression`
        and prepare to exit this

        :param on_node:
        :param on_enter:
        :param on_exit:
        """
        self.__on_node = on_node
        self.__on_enter = on_enter
        self.__on_exit = on_exit
        #
        self.__current_expr: ComplexExpression = None
        self.__current_key: str = None

    def travel(self, root: Expression):
        if isinstance(root, ComplexExpression):
            root.travel(self)
        else:
            self.__on_node(None, None, root)

    def on_node(self, node: Expression):
        self.__on_node(self.__current_expr, self.__current_key, node)

    def on_child(self, expr: ComplexExpression, key: str, node: Optional[Expression]):
        self.__current_expr = expr
        self.__current_key = key

        if node is not None and isinstance(node, ComplexExpression):
            node.travel(self)
        else:
            self.__on_node(self.__current_expr, self.__current_key, None)

    def on_enter(self, expr: ComplexExpression) -> bool:
        if self.__on_enter is None or self.__on_enter(expr):
            return True
        else:
            return False

    def on_exit(self, expr: ComplexExpression):
        if self.__on_exit is not None:
            self.__on_exit(expr)


class BoolExpression(ComplexExpression[T]):
    """
    **json format**

    ::

        BoolExpression[T] = {
            "expression" :str = expression
            "true" = Expression[T]      # when true, property name could be:
                                        #   any lower case equal to "true"
            "false" = Expression[T]     # when false, property name could be:
                                        #   any lower case equal to "false"
                                        #   "null", "None" if "false" not present
            "*" = Expression[T]         # else. property name could be:
                                        #   any lower case equal to "else"
        }
    """

    __slots__ = ('if_true', 'if_false', 'or_else')

    def __init__(self,
                 expression: str,
                 if_true: Optional[Expression[T]] = None,
                 if_false: Optional[Expression[T]] = None,
                 or_else: Optional[Expression[T]] = None,
                 dependency: List[str] = None):
        super().__init__(expression, dependency)

        self.if_true: Optional[Expression[T]] = if_true
        self.if_false: Optional[Expression[T]] = if_false
        self.or_else: Optional[Expression[T]] = or_else

    def value(self, context: Scope) -> Union[None, str, T]:
        value = super().value(context)

        if self.if_true is not None and value:
            return self.if_true.value(context.child(VALUE=True))

        if self.if_false is not None and not value:
            return self.if_false.value(context.child(VALUE=False))

        if self.or_else is not None:
            return self.or_else.value(context.child(VALUE=value))

        else:
            return None

    def travel(self, traveler: 'ExpressionTraveler'):
        traveler.on_node(self)

        if traveler.on_enter(self):
            traveler.on_child(self, 'true', self.if_true)
            traveler.on_child(self, 'false', self.if_false)
            traveler.on_child(self, 'else', self.or_else)
            traveler.on_exit(self)

    def node_keys(self) -> List[str]:
        return ['true', 'false', 'else']

    def get_node(self, key: str) -> Optional[Expression[T]]:
        if key == 'true':
            return self.if_true
        elif key == 'false':
            return self.if_false
        elif key in ('*', 'else'):
            return self.or_else
        else:
            return super().get_node(key)

    def set_node(self, key: str, node: Optional[Expression[T]]):
        key = key.lower()
        if key == 'true':
            self.if_true = node
        elif key == 'false':
            self.if_false = node
        elif key in ('*', 'else'):
            self.or_else = node
        else:
            super().set_node(key, node)

    def as_json(self):
        ret: Dict[str, Any] = super().as_json()

        if self.if_true is not None:
            ret['true'] = self.if_true.as_json()

        if self.if_false is not None:
            ret['false'] = self.if_false.as_json()

        if self.or_else is not None:
            ret['else'] = self.or_else.as_json()

        return ret

    @classmethod
    def parse(cls, json: JSON_OBJECT) -> 'BoolExpression':
        expression = _get(json, 'expression', str, 'bool expression')

        if_true = None
        if_false = None
        or_else = None

        for k, v in json.items():
            k = k.lower()

            if k == 'true':
                if if_true is None:
                    if_true = Expression.parse(v)
                else:
                    raise RuntimeError('bool expression "true" duplicate : ' + _truncate(json))
            elif k == 'false':
                if if_false is None:
                    if_false = Expression.parse(v)
                else:
                    raise RuntimeError('bool expression "false" duplicate : ' + _truncate(json))

            elif k in ('*', 'else'):
                if or_else is None:
                    or_else = Expression.parse(v)
                else:
                    raise RuntimeError('bool expression "else" duplicate : ' + _truncate(json))

            else:
                raise RuntimeError('unknown bool condition : ' + k + ' in ' + _truncate(json))

        dep = _get(json, 'dependency', (str, list), 'when expression', nullable=True)
        if dep is not None:
            if isinstance(dep, str):
                dep = [dep]
            else:
                dep = list(map(str, dep))

        return BoolExpression(expression, if_true, if_false, or_else, dep)


class ListExpression(ComplexExpression[T]):
    """
    **json format**

    ::

        ListExpression[T] = {
            "expression"? :str = expression
            "list": [T|Expression[T]]
        }
    """

    __slots__ = ('_list',)

    def __init__(self,
                 exp_list: List[Union[T, Expression[T]]],
                 expression: str = None,
                 dependency: List[str] = None):
        super().__init__(expression, dependency)

        self._list: List[Expression[T]] = exp_list

    def value(self, context: Scope) -> Union[str, T]:
        if self.expression is not None:
            value = context.eval(self.expression)
        else:
            value = context["VALUE"]

        element = self._list[int(value)]
        if isinstance(element, Expression):
            return element.value(context.child(VALUE=value))
        else:
            return element

    def travel(self, traveler: ExpressionTraveler):
        traveler.on_node(self)

        if traveler.on_enter(self):

            for i, e in enumerate(self._list):
                traveler.on_child(self, str(i), e)

            traveler.on_exit(self)

    def node_keys(self) -> List[str]:
        return list(map(str, range(len(self._list))))

    def get_node(self, key: str) -> Union[T, Expression[T]]:
        try:
            return self._list[int(key)]
        except (ValueError, IndexError):
            pass

        return super().get_node(key)

    def set_node(self, key: str, node: Union[T, Expression[T]]):
        try:
            # exam key
            self._list[int(key)]
        except (ValueError, IndexError) as e:
            return super().set_node(key, node)

        else:
            if node is None:
                raise RuntimeError('NoneType')

            self._list[int(key)] = node

    def as_json(self):
        ret = {
            'list': [JsonSerialize.to_json(v) for v in self._list]
        }

        if self.expression is not None:
            ret['expression'] = self.expression

        if len(self.dependency) > 0:
            ret['dependency'] = self.dependency

        return ret

    @classmethod
    def parse(cls, json: JSON_OBJECT) -> 'ListExpression':
        expression = _get(json, 'expression', str, 'list expression', nullable=True)

        exp_list = _get(json, 'list', list, 'list expression')
        exp_list = [Expression.parse(v) for v in exp_list]

        dep = _get(json, 'dependency', (str, list), 'list expression', nullable=True)
        if dep is not None:
            if isinstance(dep, str):
                dep = [dep]
            else:
                dep = list(map(str, dep))

        return ListExpression(exp_list, expression, dep)


class WhenExpression(ComplexExpression[T]):
    """
    **json format**

    ::

        WhenExpression[T] = {
            "expression" :str = expression
            "when" = {
                str_value = Expression[T]
                "*"? = Expression[T]            # else
            }
        }
    """

    __slots__ = ('_when',)

    def __init__(self,
                 expression: str,
                 when: Dict[str, Expression[T]],
                 dependency: List[str] = None):
        super().__init__(expression, dependency)

        self._when: Dict[str, Expression[T]] = when

    def value(self, context: Scope) -> Union[str, T]:
        value = super().value(context)

        key = str(value)

        if key in self._when:
            return self._when[key].value(context.child(VALUE=value))

        if '*' in self._when:
            return self._when['*'].value(context.child(VALUE=value))
        else:
            return None

    def travel(self, traveler: ExpressionTraveler):
        traveler.on_node(self)

        if traveler.on_enter(self):
            for k in list(self._when.keys()):
                traveler.on_child(self, k, self._when[k])
            traveler.on_exit(self)

    def node_keys(self) -> List[str]:
        return list(self._when.keys())

    def get_node(self, key: str) -> Expression[T]:
        if key in self._when:
            return self._when[key]
        else:
            return super().get_node(key)

    def set_node(self, key: str, node: Optional[Expression[T]]):
        if node is not None:
            self._when[key] = node

        elif key in self._when:
            del self._when[key]

    def as_json(self):
        ret: Dict[str, Any] = super().as_json()

        ret['when'] = {k: v.as_json() for k, v in self._when.items()}

        return ret

    @classmethod
    def parse(cls, json: JSON_OBJECT) -> 'WhenExpression':
        expression = _get(json, 'expression', str, 'when expression')

        when = _get(json, 'when', dict, 'when expression')
        when = {k: Expression.parse(v) for k, v in when.items()}

        dep = _get(json, 'dependency', (str, list), 'when expression', nullable=True)
        if dep is not None:
            if isinstance(dep, str):
                dep = [dep]
            else:
                dep = list(map(str, dep))

        return WhenExpression(expression, when, dep)


class GuardExpression(ComplexExpression[bool]):
    """guard expression, if *expression* is not satisfy, which fail the ``if`` test,
    program will raise an error.

    **json format**

    ::

        GuardExpression
            = expression:str
            | guard_instance

        guard_instance = {
            "expression" : str = expression
            "error_type"? :str
            "raise"? :str
        }

    """
    __slots__ = ('_error_type', '_message')

    def __init__(self,
                 expression: str,
                 message: Optional[str] = None,
                 error_type: Optional[str] = None):
        super().__init__(expression)

        self._error_type = error_type
        self._message = message

    @property
    def error_type(self):
        if self._error_type is None:
            return RuntimeError

        # noinspection PyBroadException
        try:
            e = eval(self._error_type)
        except:
            return RuntimeError
        else:
            if isinstance(e, BaseException):
                return e
            else:
                return RuntimeError

    @property
    def error_message(self) -> Optional[str]:
        return self._message

    def value(self, context: Scope) -> None:
        if not super().value(context):
            self.raise_error()

    def test(self, context: Scope) -> bool:
        return super().value(context)

    def raise_error(self):
        if self._message is None:
            message = 'guard : ' + self.expression

        else:
            message = self._message

        # noinspection PyBroadException
        try:
            err = self.error_type(message)
        except:
            err = None

        if isinstance(err, BaseException):
            raise err

        else:
            raise RuntimeError(message)

    def as_json(self):
        ret = {
            'expression': self.expression
        }

        if self._error_type is not None:
            ret['error_type'] = self._error_type

        if self._message is not None:
            ret['raise'] = self._message

        return ret

    @classmethod
    def parse(cls, json: JSON) -> 'GuardExpression':
        if isinstance(json, str):
            return GuardExpression(json)

        elif isinstance(json, dict):
            expression = _get(json, 'expression', str, 'guard expression')
            error_type = _get(json, 'error_type', str, 'guard expression', nullable=True)
            message = _get(json, 'raise', str, 'guard expression', nullable=True)

            return GuardExpression(expression, message=message, error_type=error_type)

        else:
            raise RuntimeError('illegal guard expression : ' + _truncate(json))


class ListGuardExpression(ListNode[GuardExpression]):
    """
    **json format**

    ::

        ListGuardExpression
            = [GuardExpression]

    """

    __slots__ = ()

    def __init__(self, init: List[GuardExpression] = None):
        super().__init__(init if init is not None else [])

    def value(self, context: Scope) -> None:
        """testing all guard expression

        :param context:
        """
        for e in self:
            e.value(context)

    def test(self, context: Scope) -> Optional[GuardExpression]:
        """testing all guard expression.

        :param context:
        :return: the first failed guard expression. None if all pass
        """
        for e in self:
            if not e.test(context):
                return e

        return None

    @classmethod
    def parse(cls, json: JSON_ARRAY) -> 'ListGuardExpression':
        return ListGuardExpression(_list(json, GuardExpression.parse))