import tools.async
import itertools
import heapq
import random
import time


def get_adder(l):
    def _adder(v):
        l.append(v)
    return _adder


def get_remover(l):
    def _remover(v):
        l.remove(v)
    return _remover


def complete_on(on_list, f):
    def _f(*args, **kwargs):
        value = f(*args, **kwargs)
        for _on in on_list:
            _on()
        return value
    return _f

random.seed(time.time().is_integer())



invoke = lambda f, *args, **kwargs: f(*args, **kwargs)


class Observable():
    def __init__(self, default_value=None):
        var = default_value

        def _set(value):
            def assign():
                nonlocal var
                var = value
            invoke(assign)

        onset = []
        self.add_onset = get_adder(onset)
        self.remove_onset = get_remover(onset)
        self.set = complete_on(onset, _set)

        def _get():
            return var

        onget = []
        self.add_onget = get_adder(onget)
        self.remove_onget = get_remover(onget)
        self.get = complete_on(onget, _get)

        hash = random.randint(0, 2**63 + (2**63 - 1))
        self.__hash__ = lambda: hash.__hash__()


class UpdateableModel:
    def __init__(self, *observables, updater=lambda: None, update_with_eq_value=False):
        var = None
        def _get():
            return var

        def _set(value):
            nonlocal var
            var = value
        onget = []
        onset = []
        self.add_onget = get_adder(onget)
        self.add_onset = get_adder(onset)
        self.remove_onget = get_remover(onget)
        self.remove_onset = get_remover(onset)
        self.get = complete_on(onget, _get)
        setter = complete_on(onset, _set)

        def _update():
            value = updater()
            if value != var or update_with_eq_value:
                setter(value)

        self._update = _update

        self._deep = 0

        for obs in observables:
            if isinstance(obs, UpdateableModel):
                self._deep = max(self._deep, obs._deep + 1)
                obs.add_onset(lambda: invoke(self._update))
            elif isinstance(obs, Observable):
                self._deep = max(self._deep, 1)
                obs.add_onset(lambda: invoke(self._update))
            else:
                raise ValueError('В observables хранятся не все значения')

        self._update()

        hash = random.randint(0, 2**63 + (2**63 - 1))
        self.__hash__ = lambda: hash.__hash__()