from twisted.internet import defer

import re
from decorator import decorator
from inspect import getcallargs
import types

from .error import ValidateException, InvalidTel, InvalidMail
from .telnumber import Telnumber

def vBool(value, field):
    '''Validate function  for boolean values
    
    :return: **value**
    :raises: :exc:`iro.error.ValidateException`
    '''
    t=[True, 1, "true", "True", "TRUE"]
    f=[False, 0, "false", "False", "FALSE"]
    if value in t:
        return True
    elif value in f:
        return False
    else:
        raise ValidateException(field=field, msg='%s is not boolean' % field)


def vInteger(value, field, minv=None, maxv=None, none_allowed=False):
    """validate function for integer values.

    :param integer minv: minimum value
    :param integer maxv: maximum value
    :param boolean none_allowed: is None or empty string allowed
    :return: **value**
    :raises: :exc:`iro.error.ValidateException`
    """
    if none_allowed and value in [None,'']:
        return None

    try:
        ret = int(value)
    except ValueError:
        raise ValidateException(field=field)
    except TypeError:
        raise ValidateException(field=field)

    if minv is not None and ret < minv:
        raise ValidateException(field=field)

    if maxv is not None and ret > maxv:
        raise ValidateException(field=field)

    return ret

def vHash(value,field,minlength=None,maxlength=None):
    '''Validate function for hash values
    
    :param integer minlength: minimum length of value string
    :param integer maxlength: maximum length of value string
    :return: **value**
    :raises: :exc:`iro.error.ValidateException`
    '''
    if not re.match(r'^[a-f0-9]*$', value.lower()):
        raise ValidateException(field=field)
    if minlength and len(value)<minlength:
        raise ValidateException(field=field)
    if maxlength and len(value)>maxlength:
        raise ValidateException(field=field)
    return value.lower()

def vTel(value,field):
    '''Validator for telefon numbers
    :return: **value**
    :raises: :exc:`iro.error.InvalidTel`
    '''

    ret = []
    for v in value:
        try:
            tel=Telnumber(v)
            if tel not in ret:
                ret.append(tel)
        except InvalidTel, e:
            e.field=field
            raise e
    return ret

def vEmail(value, field, allowString=True, allowList=True):
    '''validator for emailadresses (see wikipeda for strange mailadresses and RFC3696)
    
    valid:

    - "very.(),:;<>[]\\".VERY.\\"very@\\\ \\"very\\".unusual"@strange.example.com
    - ""@example.org
    - "very.unusual.@.unusual.com"@example.com'

    not valid:
    
    - Abc.@example.com
    - Abc..123@example.com
    - thisis."notallowed@example.com
    - this\\ still\\"not\\allowed@example.com
   
    :param boolean allowString: value can be a string -> a string is returned
    :param boolean allowList: value is a a list -> a list is returned
    :return: **value**
    :raises: :exc:`iro.error.ValidateException`, :exc:`iro.error.InvalidMail`
    '''
    ret = []
    str_=False
    if type(value) is types.StringType:
        if not allowString:
            raise ValidateException('%s must be a list of email addresses.'%field)
        str_=True
        value=[value]
    elif not allowList:
        raise ValidateException('%s must be a email address - No list of email addresses.'%field)
    for v in value:
        parts= re.match(r'^(.*)@(.+?)$',v)
        if not parts:
            raise InvalidMail(v,field)
        local=parts.group(1)
        domain=parts.group(2)
        
        if not re.match(r'^(\[[0-9\.]{7,16}\]|\[[0-9a-f:]{3,}\]|([a-z0-9+\-%_]+\.)+[a-z]{2,6})$',domain.lower()):
            raise InvalidMail(v,field)
       
        if local == "":
            ret.append(v)
            continue
    
        if local.startswith(".") or local.endswith("."):
            raise InvalidMail(v,field)
        unquote = True
        parts = local.split('"')
        c=0
        i=0
        for part in parts:
            if unquote and part != "":                     #unquoted is not allowd so much
                if not re.match(r'^[^\\,\[\];\(\)@<>: ]+$',part) or ".." in part:
                    raise InvalidMail(v,field)
            if i == 0:
                if unquote and part != "" and len(parts) > 1 and part[-1] != '.': #quoted parts must be seperated by a dot
                    raise InvalidMail(v,field)
                unquote = not unquote
                c+=1
            elif part == ''  or part[-1] != "\\":
                if unquote and part != "":         #quoted parts must be seperated by a dot
                    if part[0] != ".":
                        raise InvalidMail(v,field)
                    if i < len(parts)-1 and part[-1] != '.':
                        raise InvalidMail(v,field)
                unquote = not unquote
                c += 1
            i += 1
        if c%2 == 0 and c > 1:                        #no single quote allowed
            raise InvalidMail(v,field)
        if v not in ret:
            ret.append(v)
    if str_:
        ret=ret[0]
    return ret

def validate(kwd,func, need=True,*args,**kargs):
    '''validate decorator.

    :param string kwd: keyword to validate
    :param func func: validate function
    :param boolean need: ``False`` -- ``None`` is a valid value for kwd
    :params args: arguments for validate function
    :params kargs: keyword arguments for validate function

    .. note:: this decorator can handle function that returns a defer object.
    
    use it like this::

      @validate(kwd=userhash, func=vuserhash)
      f(userhash)
    
    that will validate ``userhash`` with the function **vuserhash**.
    Every validate function should raise an Exception, if the the value is not valid.
    All **args** and **kargs** are used to call the validate function.
    if **need** is True, the kwd can't be `None`.
    '''
    @decorator
    def v(f,*a,**k):
        kp=getcallargs(f,*a,**k)
        def dfunc(*x,**y):
            return None
        try:
            if kp[kwd] is not None:
                dfunc=func
            elif need:
                raise ValidateException(field=kwd,msg="%s is nessasary"%kwd)
        except KeyError:
            if need:
                raise ValidateException(field=kwd,msg="%s is nessasary"%kwd)
            kp[kwd] = None

        def _gotResult(value):
            kp[kwd] = value
            e = defer.maybeDeferred(f,**kp)
            return e
        d = defer.maybeDeferred(dfunc, kp[kwd],kwd,*args,**kargs)
        return d.addCallback(_gotResult)
    return v