#
# Copyright (c) 2010 Greek Research and Technology Network
#

from synnefo.api.errors import *
from synnefo.db.models import *

from django.http import HttpResponse
from django.template.loader import render_to_string

from functools import wraps
from logging import getLogger
from random import choice
from string import ascii_letters, digits
from traceback import format_exc
from xml.etree import ElementTree
from xml.parsers.expat import ExpatError

import json


log = getLogger('synnefo.api')


def tag_name(e):
    ns, sep, name = e.tag.partition('}')
    return name if sep else e.tag

def xml_to_dict(s):
    # XXX Quick and dirty
    def _xml_to_dict(e):
        root = {}
        d = root[tag_name(e)] = dict(e.items())
        for child in e.getchildren():
            d.update(_xml_to_dict(child))
        return root
    return _xml_to_dict(ElementTree.fromstring(s.strip()))

def get_user():
    # XXX Placeholder function, everything belongs to a single SynnefoUser for now
    try:
        return SynnefoUser.objects.all()[0]
    except IndexError:
        raise Unauthorized

def get_request_dict(request):
    data = request.raw_post_data
    if request.type == 'xml':
        try:
            return xml_to_dict(data)
        except ExpatError:
            raise BadRequest
    else:
        try:
            return json.loads(data)
        except ValueError:
            raise BadRequest

def random_password(length=8):
    pool = ascii_letters + digits
    return ''.join(choice(pool) for i in range(length))


def render_fault(request, fault):
    if settings.DEBUG or request.META.get('SERVER_NAME', None) == 'testserver':
        fault.details = format_exc(fault)
    if request.type == 'xml':
        mimetype = 'application/xml'
        data = render_to_string('fault.xml', dict(fault=fault))
    else:
        mimetype = 'application/json'
        d = {fault.name: {'code': fault.code, 'message': fault.message, 'details': fault.details}}
        data = json.dumps(d)
    return HttpResponse(data, mimetype=mimetype, status=fault.code)    

def api_method(http_method):
    def decorator(func):
        @wraps(func)
        def wrapper(request, *args, **kwargs):
            try:
                if request.path.endswith('.json'):
                    request.type = 'json'
                elif request.path.endswith('.xml'):
                    request.type = 'xml'
                else:
                    request.type = 'json'       # Default response format
                    for accept in request.META.get('HTTP_ACCEPT', '').split(','):
                        if accept == 'application/json':
                            break
                        elif accept == 'application/xml':
                            request.type = 'xml'
                            break
                
                if request.method != http_method:
                    raise BadRequest()
                
                resp = func(request, *args, **kwargs)
                resp['Content-Type'] = 'application/xml' if request.type == 'xml' else 'application/json'
                return resp
            except Fault, fault:
                return render_fault(request, fault)
            except BaseException, e:
                log.exception('Unexpected error: %s' % e)
                fault = ServiceUnavailable()
                return render_fault(request, fault)
        return wrapper
    return decorator