import threading
from collections.abc import MutableMapping


class ImmutableKVCache(MutableMapping):
    """
    Guarantees that the factory will be called for each key once, and
    only once.
    """

    def __init__(self, factory):
        self.factory = factory  # user-provided factory function
        self.lock = threading.Lock()  # guards factory_calls
        self.factory_calls = {}  # per-key factory condition variables
        self.cache = {}  # result cache, indexed by key
        super().__init__()

    def __getitem__(self, key):
        if key in self.cache:
            return self.cache[key]

        # we need to call factory.  First grab the main lock and the per-key CV.
        factory_calls = None
        creation_thr = False
        with self.lock:
            if key in self.cache:
                return self.cache[key]
            if key not in self.factory_calls:
                creation_thr = True
                self.factory_calls[key] = {'cv': threading.Condition(), 'is_done': False, 'error': None}
            factory_calls = self.factory_calls[key]

        # with the CV, create the value (or wait for it to be created)
        cv = factory_calls['cv']
        with cv:
            if creation_thr:
                try:
                    self.cache[key] = self.factory(key)
                except Exception as e:
                    factory_calls['error'] = e

                factory_calls['is_done'] = True
                cv.notify_all()
            else:
                """ wait for the value to be available """
                while not factory_calls['is_done']:
                    cv.wait()

        with self.lock:
            if key in self.factory_calls:
                del self.factory_calls[key]

        return self.cache[key]

    def __iter__(self):
        """ weak iter, don't call factory """
        return self.cache.__iter__()

    def __len__(self):
        return self.cache.__len__()

    def __contains__(self, key):
        """ weak contain - don't call factory """
        return self.cache.__contains__(key)

    def __delitem__(self, key):
        del self.cache[key]

    def __setitem__(self, key, value):
        """ unsupported """
        raise NotImplementedError