from goody import type_as_str
import inspect

class Check_All_OK:
    """
    Check_All_OK class implements __check_annotation__ by checking whether each
      annotation passed to its constructor is OK; the first one that
      fails (by raising AssertionError) prints its problem, with a list of all
      annotations being tried at the end of the check_history.
    """

    def __init__(self,*args):
        self._annotations = args

    def __repr__(self):
        return 'Check_All_OK('+','.join([str(i) for i in self._annotations])+')'

    def __check_annotation__(self, check, param, value,check_history):
        for annot in self._annotations:
            check(param, annot, value, check_history+'Check_All_OK check: '+str(annot)+' while trying: '+str(self)+'\n')


class Check_Any_OK:
    """
    Check_Any_OK implements __check_annotation__ by checking whether at least
      one of the annotations passed to its constructor is OK; if all fail
      (by raising AssertionError) this classes raises AssertionError and prints
      its failure, along with a list of all annotations tried followed by the
      check_history.
    """

    def __init__(self,*args):
        self._annotations = args

    def __repr__(self):
        return 'Check_Any_OK('+','.join([str(i) for i in self._annotations])+')'

    def __check_annotation__(self, check, param, value, check_history):
        failed = 0
        for annot in self._annotations:
            try:
                check(param, annot, value, check_history)
            except AssertionError:
                failed += 1
        if failed == len(self._annotations):
            assert False, repr(param)+' failed annotation check(Check_Any_OK): value = '+repr(value)+\
                         '\n  tried '+str(self)+'\n'+check_history



class Check_Annotation():
    # set this name to True for checking to occur
    checking_on  = True

    # self._checking_on must also be true for checking to occur
    def __init__(self,f):
        self._f = f
        self.checking_on = True

    # Check whether param's annot is correct for value, adding to check_history
    #    if recurs; defines many local function which use it parameters.
    def check(self,param,annot,value,check_history=''):

        # Define local functions for checking, list/tuple, dict, set/frozenset,
        #   lambda/functions, and str (str for extra credit)
        # Many of these local functions called by check, call check on their
        #   elements (thus are indirectly recursive)
        def list_tuple_check(p):
            assert isinstance(value,p), '{} failed annotation check(wrong type): value = {}\n was type {} ...should be type {}\n{}'.format(repr(param), repr(value), type_as_str(value), str(p), check_history)
            if len(annot) != 1:
                assert len(annot) == len(value) ,'{} failed annotation check(wrong number of elements): value = {}\n annotation had {} elements{}\n{}'.format(repr(param), repr(value), str(len(annot)),str(annot),check_history)
                a_list = list(zip(annot,value))
                for key,val in a_list:
                    self.check(param, key,val,'{}{}[{}] check: {}\n'.format(check_history,type_as_str(value),str(value.index(val)),str(annot.index(key))))
            else:
                for ann in annot:
                    for val in value:
                        self.check(param, ann,val,'{}{}[{}] check: {}\n'.format(check_history,type_as_str(value),str(value.index(val)),str(ann)))

    # Return result of calling decorated function call, checking present
    #   parameter/return annotations if required
    def __call__(self, *args, **kargs):

        # Return a dictionary of the parameter/argument bindings (actually an
        #    ordereddict, in the order parameters occur in the function's header)
        def param_arg_bindings():
            f_signature  = inspect.signature(self._f)
            bound_f_signature = f_signature.bind(*args,**kargs)
            for param in f_signature.parameters.values():
                if param.name not in bound_f_signature.arguments:
                    bound_f_signature.arguments[param.name] = param.default
            return bound_f_signature.arguments

        # If annotation checking is turned off at the class or function level
        #   just return the result of calling the decorated function
        # Otherwise do all the annotation checking
        if not (Check_Annotation.checking_on and self.checking_on):
            return self._f(*args, **kargs)

        self._b = param_arg_bindings()

        try:
            # Check the annotation for every parameter (if there is one)
            for x,y in self._b.items():
                if x in self._f.__annotations__:
                    self.check(x, self._f.__annotations__[x], y)
            # Compute/remember the value of the decorated function
            v = self._f(*args, **kargs)
            # If 'return' is in the annotation, check it
            if 'return' in self._f.__annotations__:
                self._b['_return'] = v
                self.check('_return', self._f.__annotations__['return'], v)
            # Return the decorated answer
            return v

        # On first AssertionError, print the source lines of the function and reraise
        except AssertionError:
            #===================================================================
            # print(80*'-')
            # for l in inspect.getsourcelines(self._f)[0]: # ignore starting line #
            #     print(l.rstrip())
            # print(80*'-')
            #===================================================================
            raise





if __name__ == '__main__':
    # an example of testing a simple annotation
    #===========================================================================
    # def f(x:int): pass
    # f = Check_Annotation(f)
    # f(3)
    # f('a')
    #===========================================================================

    import driver
    driver.driver()