import re
import json
import time

from datetime import datetime
from datetime import date
from datetime import timedelta

from django.conf import settings
from django.http import HttpResponse
from django.shortcuts import render_to_response

from backend.models import SJLike
from backend.models import SJRoom
from backend.models import SJContent
from backend.models import SJSearch
from backend.models import SJUserProfile

from backend.views import is_number
from backend.views import is_image
from backend.views import videos_response_list
from backend.views import ROOM_VIDEO_LOG_SIZE

from django.db.models import Q, Count

LIMIT = 40

BLOCKED_DOMAINS = {
    'dvdbeaver.com': True,
    '4chan.org': True,
    'yahoo.com': True,
    'adultswim.com': True,
}


def bg(request):
    """ Backgrounds view
    """
    query = Q(content_type='background')
    if request.GET.get('start', None):
        if is_number(request.GET['start']):
            query &= Q(id__lt=int(request.GET['start']))
    limit = LIMIT
    if request.GET.get('limit', None):
        if is_number(request.GET['limit']):
            limit = int(request.GET['limit'])
    backgrounds = SJContent.objects.filter(query).order_by('-id')[0:limit]

    filtered_backgrounds = []
    for b in backgrounds:
        s = b.settings
        url = s['url']
        if not url.startswith('http:'):
            continue
        domain = ''
        try:
            domain = '.'.join(url.split('/')[2].split('.')[-2:])
        except:
            continue
        if domain in BLOCKED_DOMAINS:
            continue
        b.domain = domain
        filtered_backgrounds.append(b)

    return render_to_response(
        'backgrounds.html',
        {
             'SERVER_HOST': settings.SERVER_HOST,
             'SERVER_PORT': settings.SERVER_PORT,
             'lowest_id': backgrounds[limit - 1].id,
             'backgrounds': filtered_backgrounds,
             'domain': domain,
        }
    )

def topvideos(request):
    """ Top videos view
    """
    today = datetime.fromtimestamp(time.mktime(date.today().timetuple()))
    tomorrow = today + timedelta(days=1)
    yersterday = today - timedelta(days=1)
    videos = SJContent.objects.filter(content_type='video') 
    top_today = videos.filter(Q(datetime__gt=today) & Q(datetime__lt=tomorrow))[0:ROOM_VIDEO_LOG_SIZE]
    top_yesterday = videos.filter(Q(datetime__gt=yersterday) & Q(datetime__lt=today))[0:ROOM_VIDEO_LOG_SIZE]
    top_alltime = videos[0:ROOM_VIDEO_LOG_SIZE]

    response = render_to_response(
        'topvideos.html',
        {
             'SERVER_HOST': settings.SERVER_HOST,
             'SERVER_PORT': settings.SERVER_PORT,
             'top_today': json.dumps(videos_response_list(top_today)),
             'top_yesterday': json.dumps(videos_response_list(top_yesterday)),
             'top_alltime': json.dumps(videos_response_list(top_alltime)),
        }
    )
    response['Pragma'] = 'no-cache'
    return response

def directory(request):
    """ Directory view
    """
    r = []
    for u in SJUserProfile.objects.order_by('-score'):
	r.append({ 'id': u.id, 'name': u.nickname, 'score': u.score })

    response = render_to_response(
        'directory.html',
        {
             'SERVER_HOST': settings.SERVER_HOST,
             'SERVER_PORT': settings.SERVER_PORT,
             'directory': json.dumps(r),
	}
    )
    response['Pragma'] = 'no-cache'
    return response

def get_thumbnail(user):
	STOCK_THUMBNAIL = 'http://scannerjammer.fm/img/runner.gif'
	"""
	FIXME
	if user.access and 'http' in user.access: # what was those fields? 
		linez = user.access.split("\n")
		for l in linez:
			if "avatar" in l:
				pair = l.split("\t")
				if pair[1] is not None and "http" in pair[1]:
					if db.is_image(pair[1]):
						return pair[1]
	if user[8] and 'http' in user[8]:
		linez = user[8].split("\n")
		for l in linez:
			if "http" in l:
				wordz = l.split(" ")
				for word in wordz:
					if "http" in word:
						if db.is_image(word):
							return word
	"""
	return STOCK_THUMBNAIL


def profile(request, username):
    """ Directory view
    """

    userprofile = SJUserProfile.objects.filter(user__username=username)[0];
    thumbnail = get_thumbnail(userprofile)
    
    topz  = SJContent.objects.filter(user__id=userprofile.user.id, content_type='video').annotate(likes=Count('sjlike')).order_by('-likes')[:50]
    likez = SJContent.objects.filter(user__id=userprofile.user.id, content_type='video', sjlike__isnull = False ).order_by('-datetime')[:50]
    vidz  = SJContent.objects.filter(user__id=userprofile.user.id, content_type='video').order_by('-datetime')[:50]
    profile = [ userprofile.id, userprofile.nickname, userprofile.score, 3, 4, 5, userprofile.bio, json.loads(userprofile.settings_text) ]

    response = render_to_response(
        'profile.html',
        {
             'SERVER_HOST': settings.SERVER_HOST,
             'SERVER_PORT': settings.SERVER_PORT,
             'NAME': userprofile.nickname,
	     'UCNAME': userprofile.nickname.upper(),
	     'SCORE': userprofile.score,
	     'THUMBNAIL': thumbnail,
	     
	     'VIDZ': json.dumps(videos_response_list(vidz)),
	     'TOPZ': json.dumps(videos_response_list(topz)),
	     'LIKEZ': json.dumps(videos_response_list(likez)),
	     'PROFILE': json.dumps(profile),
	     
	     'NOW': str(int(time.time())),
	}
    )
    response['Pragma'] = 'no-cache'
    return response

def roomlist(request):
    recenttime = datetime.fromtimestamp(time.time() - 86400)
    
    roomlist = []
    sjrooms = SJRoom.objects.all()
    for r in sjrooms:
    	s = json.loads(r.settings_text)
	video_count = r.sjcontent_set.filter(datetime__gt=recenttime).count()
	if 'bg' in s:
		roomlist.append([r.id, r.name, int(r.datetime.strftime("%s")), video_count, s["bg"]])	
 
    response = render_to_response(
        'roomlist.html',
        {
             'ROOM_LIST': json.dumps(roomlist),
	}
    )
    response['Pragma'] = 'no-cache'
    return response

def room(request, roomname):
    sjroom = SJRoom.objects.filter(name=roomname)[0];
    jsPath = "/js/sj6.js"
    
    title = sjroom.name.capitalize() + " room on ScannerJammer"
    thumbnail = "http://scannerjammer.fm/img/plant.gif"
    if sjroom.name == "glitter":
        thumbnail = "http://scannerjammer.fm/img/glitter_flower.gif"
    elif sjroom.name == "glasspopcorn":
        thumbnail = "http://scannerjammer.fm/img/glasspopthumb.gif"
        title = "GlassPopcorn TV"
    elif room == "adult":
        #serverPort = 6969
        jsPath = "/js/sandbox/sj7.js"
    elif room != "main":
	s = json.loads(sjroom.settings_text)
	if "bg" in s:
		thumbnail = s["bg"]
    
    response = render_to_response(
        'room.html',
        {
             'SERVER_HOST': settings.SERVER_HOST,
             'SERVER_PORT': settings.SERVER_PORT,
             'JS_PATH': jsPath,
             'ROOM':    sjroom.name.lower(),
             'UCROOM':	sjroom.name.upper(),
	     'OPENGRAPH_IMAGE': thumbnail,
	     'OPENGRAPH_TITLE': title,
	}
    )
    response['Pragma'] = 'no-cache'
    return response