from pyramid.view import view_config
from pyramid.renderers import get_renderer
from pyramid.httpexceptions import HTTPFound
from pyramid.security import remember
from pyramid.security import forget
from pyramid.security import authenticated_userid
from pyramid_mailer import get_mailer, message

from ultima.models import transaction
from ultima.models import DBSession
from ultima.models import User
from ultima.models import Game
from ultima.models import Course

from sqlalchemy.orm.exc import NoResultFound

import bcrypt
import re

#User system is to be rebuilt so that it uses built in authentication and authorization
#SHOWS CURRENT USER OR USER WITH GIVEN ID
@view_config(route_name='user_show', renderer="../templates/user_show.pt")
def show(request):
    username = "Not logged in"
    main = get_renderer("../templates/master.pt").implementation()
    try:
        username = authenticated_userid(request)
        dbsession = DBSession()
        user = dbsession.query(User).filter_by(username=username).one()
        return {'test':'test', 'main':main, 'username':username, 'user':user}
    except:
        url=request.route_url('user_login')
        return HTTPFound(location=url)

#REGISTER FORM RENDERER
@view_config(route_name='user_register', request_method="GET", renderer="../templates/user_signup.pt")
def register(request):
    main = get_renderer('../templates/master.pt').implementation()
    return {'project':'ultima', 'main':main, 'emailerror':'', 'passworderror':''}

#Signup FORM POST HANDLER
@view_config(route_name='user_signup', request_method="POST", renderer="../templates/user_signup.pt")
def signup(request):
    #if re.match("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$", email) != None: #email validation
    main = get_renderer('../templates/master.pt').implementation()
    username = request.params['username']
    email = request.params['email']
    emailverification = request.params['emailverification']
    password = request.params['password']
    passwordverification = request.params['passwordverification']
    emailerror = ""
    passworderror = ""
    errors = False
    if password != passwordverification:
        passworderror = "Passwords do not match"
        errors = True
    if len(password) < 6:
        passworderror = "Password to short"
        errors = True
    if email != emailverification:
        emailerror = "Email do not match"
        errors = True
    if re.match("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$", email) == None:
        emailerror = "This is not a valid email address"
        errors = True
    if errors == False:
        salt = bcrypt.gensalt()
        hashed = bcrypt.hashpw(password, salt)
        newuser = User(username, email, hashed, salt)
        DBSession()
        DBSession.add(newuser)
    DBSession.flush()
    transaction.commit()
    mailer = get_mailer(request)
    message = Message(subject="Welcome to discgolfus",
                  sender="admin@discgolf.hjonsson.nu",
                  recipients=[email],
                  body="Welcome to discgolfus, you are now signed up. Enjoy the service!")
    mailer.send(message)
    request.session['user'] = username
        url=request.route_url('user_show')

        return HTTPFound(location=url)


    return {'firstname':firstname, 'project':'ultima', 'session':request.session, 'main':main, 'emailerror':emailerror, 'passworderror':passworderror}
    session.flush()

#LOGIN FORM RENDERER
@view_config(route_name='user_login', renderer="../templates/user_login.pt")
def login(request):
    if request.POST:
    main = get_renderer('../templates/master.pt').implementation()
    errors = False
    username = request.params['username']
    password = request.params['password']
    if errors == False:
        try:
        session = DBSession()
        user = session.query(User).filter_by(username=username).one()
        except NoResultFound, e:
        user = False
        fail = "Bad username or password"
        if user:
        salt = user.password_salt
        password_hash = bcrypt.hashpw(password, salt)
        if password_hash == user.password_hash:
            headers = remember(request, username)
            fail = ""
            url=request.route_url('home')
            return HTTPFound(location=url, headers=headers)
        else:
            fail = "Bad username or password"
    return {'project':'ultima', 'main':main, 'user':username, 'fail':fail}
    else:
    main = get_renderer('../templates/master.pt').implementation()
    return {'request':request, 'project':'ultima', 'session':request.session, 'main':main, 'fail':""}

#SIGNOUT HANDLER
@view_config(route_name='user_signout', request_method="GET", renderer="../templates/user_login.pt")
def signout(request):
    try:
        headers = forget(request)
        url=request.route_url('home')
        return HTTPFound(location=url, headers = headers)
    except KeyError:
        pass
    main = get_renderer('../templates/master.pt').implementation()
    return {'request':request, 'project':'ultima', 'main':main, 'fail':''}

@view_config(route_name="user_mycourses", request_method="GET", renderer="../templates/user_mycourses.pt")
def mycourses(request):
    main = get_renderer("../templates/master.pt").implementation()
    try:
        username = authenticated_userid(request)
    except:
        url=request.route_url('user_login')
        return HTTPFound(location=url)
    try:
        user = DBSession.query(User).filter_by(username=username).one()
        courses = DBSession.query(Course).all()
    except:
        return {'main':main, 'courses':''}
    return {'main':main, 'courses':courses}


@view_config(route_name="user_mygames", request_method="GET", renderer="../templates/user_mygames.pt")
def mygames(request):
    main = get_renderer("../templates/master.pt").implementation()
    try:
        username = authenticated_userid(request)
        user = DBSession.query(User.id).filter_by(username=username).one()
        games = DBSession.query(Game).filter_by(owner=user[0])
        return {'main':main, 'games':games}
    except:
        url=request.route_url('user_login')
        return HTTPFound(location=url)