import simplejson as json
import datetime

from webtest import TestApp

from oauth2_server import Server, gentoken

server = None
app = None

def apptest(func):
    def wrapper():
        g = globals()

        EmailMachine.emails = []
        EntropyMachine.next = []
        TimeMachine.now = datetime.datetime(2010, 6, 17, 0, 32, 33, 985904)

        g['server'] = Server(['bob@foo.com', 'jane@bar.com'],
                             send_email=EmailMachine.send_email,
                             utcnow=TimeMachine.utcnow,
                             gentoken=EntropyMachine.gentoken)
        g['app'] = TestApp(server.wsgi_app)

        func()

    wrapper.__name__ = func.__name__
    return wrapper

class EmailMachine(object):
    emails = []

    @classmethod
    def send_email(klass, email, token):
        klass.emails.append((email, token))

class EntropyMachine(object):
    next = []

    @classmethod
    def gentoken(klass):
        if klass.next:
            return klass.next.pop()
        return gentoken()

class TimeMachine(object):
    now = None

    @classmethod
    def travel(klass, timedelta=None, *args, **kwargs):
        if timedelta is None:
            timedelta = datetime.timedelta(*args, **kwargs)

        klass.now += timedelta

    @classmethod
    def utcnow(klass):
        return klass.now

def post_json(url, obj, **kwargs):
    return app.post(url, json.dumps(obj),
                    {'Content-Type': 'application/json'},
                    **kwargs)

@apptest
def test_request_challenge():
    EntropyMachine.next.append('a token')
    resp = post_json(server.request_challenge_path,
                     {'email': 'bob@foo.com'})
    assert resp.json == {'success': True}
    assert EmailMachine.emails == [('bob@foo.com', 'a token')]

@apptest
def test_request_challenge_with_invalid_email():
    post_json(server.request_challenge_path,
              {'email': 'invalid@foo.com'},
              status=400)

@apptest
def test_request_challenge_with_invalid_body1():
    post_json(server.request_challenge_path,
              [],
              status=400)

@apptest
def test_request_challenge_with_invalid_body2():
    post_json(server.request_challenge_path,
              {'blah': 'narg'},
              status=400)

@apptest
def test_respond_to_challenge():
    token = server.new_challenge_token('bob@foo.com')
    EntropyMachine.next.append('my auth token')
    resp = post_json(server.respond_to_challenge_path,
                     {'token': token})
    assert resp.json == {'email': 'bob@foo.com',
                         'token': 'my auth token'}

@apptest
def test_respond_to_challenge_only_works_once():
    token = server.new_challenge_token('bob@foo.com')
    EntropyMachine.next.append('my auth token')
    resp = post_json(server.respond_to_challenge_path,
                     {'token': token})
    assert resp.json == {'email': 'bob@foo.com',
                         'token': 'my auth token'}
    post_json(server.respond_to_challenge_path,
              {'token': token},
              status=400)

@apptest
def test_respond_to_challenge_with_invalid_token():
    post_json(server.respond_to_challenge_path,
              {'token': 'hello there'},
              status=400)

@apptest
def test_respond_to_challenge_with_invalid_body():
    post_json(server.respond_to_challenge_path,
              [],
              status=400)

@apptest
def test_basic_404():
    app.get('/blarg', status=404)