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):
    '''Validator for boolean values'''
    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):

    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):
    '''Validator for hash values'''
    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 Telefonnumbers'''
    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
    '''
    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
use it like this:
  @validate(kwd=userhash, func=vuserhash)
  f(userhash)
that will validate usrhash 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