# Create your views here.

from django.contrib import auth
from django.views.decorators.http import require_POST
from django.http import HttpResponse
from django.http import HttpResponsePermanentRedirect
from django.template import loader
from django.template import Context
from django.shortcuts import render_to_response
from django.conf import settings
from datetime import datetime

import sha

from backend.models import SJUserProfile

API_HEADER = '#@scanjam 0.3b\n'

#
# Common funtions
#

def set_cors_headers(response):
    """ Setup additional headers for response
    """
    response['Access-Control-Allow-Origin'] = '*'
    response['Access-Control-Allow-Methods'] = 'POST, GET, OPTIONS'
    response['Access-Control-Allow-Headers'] = 'x-requested-with'
    response['Access-Control-Max-Age'] = '3628800'
    response['Content-type'] = 'text/plain; charset=UTF-8'

def api_error(error, response=None):
    """ Add API error name to response
    """
    if not response:
        response = HttpResponse()
    response.write(API_HEADER)
    response.write('0\t%s\n' % error)
    return response

def api_error_headers(error, response=None):
    """ Add API error name with setup headers to response
    """
    if not response:
        response = HttpResponse()
    set_cors_headers(response)
    return api_error(error, response)

def api_ok_headers(response=None):
    """ Add API OK with setup headers to response
    """
    if not response:
        response = HttpResponse()
    set_cors_headers(response)
    response.write(API_HEADER)
    response.write('OK\n')
    return response

def check_form_fields(request, form_fields):
    """ Check form fields presence
    """
    for field, value in request.POST.iteritems():
        print field, '= "%s"' % value
    for field in form_fields:
        if field not in request.POST:
            return api_error_headers('incomplete form')
        if not request.POST[field]:
            return api_error_headers('no %s' % field)

def user_response_str(request, user=None):
    """ Return API response string for user
    """
    if not user:
        user = request.user
    if user.is_authenticated():
        user_id = user.id
        username = user.username
        session_id = request.session.session_key
        user_access = user.get_profile().access
    else:
        user_id = 0
        username = 'anonymous'
        session_id = sha.new('No valid session').hexdigest()
        user_access = 0
    return '%d\t%s\t%s\t%d\n' % (user_id, username, session_id, user_access)

#
# AUTH API
#

@require_POST
def api_auth_login(request):
    """ Log in user. Public API
    """
    form_fields = ['username', 'password']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    user = auth.authenticate(username=request.POST['username'],
                             password=request.POST['password'])
    if user:
       if user.is_active:
           auth.login(request, user)
           response = api_ok_headers()
           response.write(user_response_str(request))
           return response
       else:
           return api_error_headers('user disabled')
    else:
        if auth.models.User.objects.filter(username=request.POST['username']):
            return api_error_headers('wrong password')
        else:
            return api_error_headers('no such user')

@require_POST
def api_auth_logout(request):
    """ Log out user. Public API
    """
    auth.logout(request)
    return api_ok_headers()

@require_POST
def api_auth_sneakin(request):
    """ Sneak in user. Public API
    """
    form_fields = ['userid', 'username']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    try:
        user = auth.models.User.objects.get(username=request.POST['username'])
        if user.id != int(request.POST['userid']):
            return api_error_headers('no match')
    except:
       return api_error_headers('no such user')
    # Hack to authenticate user manually
    for backend in auth.get_backends():
        user.backend = "%s.%s" % (backend.__module__, backend.__class__.__name__)
        break
    auth.login(request, user)
    response = api_ok_headers()
    response.write(user_response_str(request, user))
    return response

@require_POST
def api_auth_register(request):
    """ Register new user. Public API
    """
    form_fields = ['username', 'password']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    if auth.models.User.objects.filter(username=request.POST['username']):
        return api_error_headers('user exists')
    user = auth.models.User.objects.create_user(username=request.POST['username'],
                                                email='default@noemail.com',
                                                password=request.POST['password'])
    user.is_active = True
    try:
        user.save()
    except:
        return api_error_headers('db error')
    user_profile = SJUserProfile(user=user,
                                 username=request.POST['username'],
                                 password=request.POST['password'],
                                 joindate=user.date_joined,
                                 seendate=user.date_joined)
    try:
        user_profile.save()
    except:
        return api_error_headers('db error')
    response = api_ok_headers()
    response.write(user_response_str(request, user))
    return response

@require_POST
def api_auth_available(request):
    """ Check if user exists. Public API
    """
    form_fields = ['username']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    if auth.models.User.objects.filter(username=request.POST['username']):
        return api_error_headers('user exists')
    return api_ok_headers()

@require_POST
def api_auth_checkin(request):
    """ Check in user. Private API
    """
    if request.user.is_authenticated():
        response = api_ok_headers()
        response.write(user_response_str(request))
        return response
    return HttpResponse()

@require_POST
def api_auth_password(request):
    """ Change user password. Private API
    """
    form_fields = ['username', 'password']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    if request.user.is_authenticated() and request.user.username == request.POST['username']:
        try:
            user = auth.models.User.objects.get(username=request.POST['username'])
            user.set_password(request.POST['password'])
            user.save()
            user_profile = user.get_profile()
            user_profile.password = request.POST['password']
            user_profile.save()
        except auth.models.User.DoesNotExist:
            return api_error_headers('no such user')
        except:
            return api_error_headers('db error')
        return api_ok_headers()
    return HttpResponse()

#
# USER API
#

@require_POST
def api_user_videos(request):
    """ Public API
    """
    form_fields = ['user', 'start']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_user_likes(request):
    """ Public API
    """
    form_fields = ['user', 'start']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_user_top(request):
    """ Public API
    """
    form_fields = ['user']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_user_settings(request):
    """ Private API
    """
    form_fields = ['user', 'bio', 'settings']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

#
# ROOM API
#

@require_POST
def api_room_watch(request):
    """ Public API
    """
    form_fields = ['room', 'last']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_list(request):
    """ Public API
    """
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_view(request):
    """ Private API
    """
    form_fields = ['room', 'last']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_join(request):
    """ Private API
    """
    form_fields = ['room', 'enqueue']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_read(request):
    """ Private API
    """
    form_fields = ['room', 'enqueue']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_poll(request):
    """ Private API
    """
    form_fields = ['room', 'last', 'cam']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_settings(request):
    """ Private API
    """
    form_fields = ['room', 'settings']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_say(request):
    """ Private API
    """
    form_fields = ['room', 'msg']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_room_video(request):
    """ Private API
    """
    form_fields = ['room', 'msg']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

#
# VIDEO API
#

@require_POST
def api_video_date(request):
    """ Public API
    """
    form_fields = ['day', 'month', 'year']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_video_view(request):
    """ Private API
    """
    form_fields = ['video']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_video_like(request):
    """ Private API
    """
    form_fields = ['video']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_video_unlike(request):
    """ Private API
    """
    form_fields = ['video']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_video_remove(request):
    """ Private API
    """
    form_fields = ['video', 'room']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

@require_POST
def api_video_search(request):
    """ Private API
    """
    form_fields = ['q', 'start', 'limit']
    response = check_form_fields(request, form_fields)
    if response:
        return response
    return HttpResponse('Not implemented yet!\n')

#
# Common views
#

def stats(request):
    """ View statistics
    """
    uptime = str(datetime.now() - settings.START_TIME)
    videos_today = None
    videos_total = None
    likes_today = None
    likes_total = None
    users_total = None
    users_today = None
    users_in_main_room = None
    new_users_today = None
    rooms_total = None
    main_room_peak = None
    return render_to_response('stats.html', {'users_total': users_total,
                                             'users_today': users_today,
                                             'new_users_today': new_users_today,
                                             'videos_total': videos_total,
                                             'videos_today': videos_today,
                                             'likes_total': likes_total,
                                             'likes_today': likes_today,
                                             'rooms_total': rooms_total,
                                             'main_room_peak': main_room_peak,
                                             'uptime': uptime})

def redirect(request):
    """ Permanent redirect
    """
    response = HttpResponsePermanentRedirect(redirect_to='http://scannerjammer.com')
    template = loader.get_template('redirect.html')
    response.write(template.render(Context()))
    return response