#. -*- coding: utf-8 -
# required proxmox permissions: PVESysAdmin, PVEVMAdmin
#
# afx 2015-2016

# import site packages
import logging
import falcon
import sys
import json
import urllib.parse

#import local packages
import ioconfig
import grid
import plugin
import clientsdb

config = ioconfig.parser
logger = ioconfig.logger


def welcome():
    """displays motd in log as welcome message"""
    logger.info('###################################')
    logger.info('# proxmaster ][ (c) 2015-2016 afx #')
    logger.info('###################################')


class RequireJSON(object):
    def process_request(self, req, resp):
        if not req.client_accepts_json:
            raise falcon.HTTPNotAcceptable(
                'This API only supports responses encoded as JSON.',
                href='http://docs.examples.com/api/json')

        if req.method in ('POST', 'PUT'):
            if 'application/json' not in req.content_type:
                raise falcon.HTTPUnsupportedMediaType(
                    'This API only supports requests encoded as JSON.',
                    href='http://docs.examples.com/api/json')


class JSONTranslator(object):
    def process_request(self, req, resp):
        # req.stream corresponds to the WSGI wsgi.input environ variable,
        # and allows you to read bytes from the request body.
        #
        # See also: PEP 3333
        if req.content_length in (None, 0):
            # Nothing to do
            return

        body = req.stream.read()
        if not body:
            raise falcon.HTTPBadRequest('Empty request body',
                                        'A valid JSON document is required.')

        try:
            req.context['doc'] = json.loads(body.decode('utf-8'))

        except (ValueError, UnicodeDecodeError):
            raise falcon.HTTPError(falcon.HTTP_753,
                                   'Malformed JSON',
                                   'Could not decode the request body. The '
                                   'JSON was incorrect or not encoded as '
                                   'UTF-8.')

    def process_response(self, req, resp, resource):
        if 'result' not in req.context:
            return

        resp.body = json.dumps(req.context['result'])


def max_body(limit):
    def hook(req, resp, resource, params):
        length = req.content_length
        if length is not None and length > limit:
            msg = ('The size of the request is too large. The body must not '
                   'exceed ' + str(limit) + ' bytes in length.')

            raise falcon.HTTPRequestEntityTooLarge(
                'Request body is too large', msg)

    return hook


#API methods
class ValidateResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp):
        """ get clientemail and password and compare it with the client db and returns a list of managed object IDs """
        json = req.context['doc']
        apipass = json['apikey']
        if apipass != config.get('general', 'apipass'):
            resp.status = falcon.HTTP_404
            logger.error('grid> access denied. bad api key!')
            return None
        
        clientemail = json['clientemail']
        passwd = json['password']

        logger.info('grid> access requested for {} with {}'.format(clientemail, passwd))

        response = clientsdb.validate(clientemail, passwd)
        resp.status = falcon.HTTP_202
        req.context['result'] = response


class ClusterResource(object):
    def on_get(self, req, resp):
        """TEST ONLY. List cluster nodes. TEST ONLY"""
        json = req.context['doc']
        apipass = json['apikey']
        if apipass != config.get('general', 'apipass'):
            resp.status = falcon.HTTP_404
            logger.error('grid> access denied. bad api key!')
            return None

        logger.info('grid> cache status')

        response = grid.sync(False)
        resp.status = falcon.HTTP_202
        req.context['result'] = response
 


    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp):
        """Create a cluster node, returns array of: status, vmid, pass, ipv4, """
        logger.info('grid> create ' + str(req.params))
        apicheck_stat, apicheck_resp = apicheck(req.params)
        if apicheck_stat:
            resp.status = falcon.HTTP_200
            try:
                resp.body = urllib.parse.urlencode(plugin.vmcreate(req.params))
            except:
                logger.error('grid> create function cancelled')
                raise
                resp.status = falcon.HTTP_403
                response = 'CREATE ERR'
                resp.body = response
        else:
            resp.status = falcon.HTTP_403
            resp.body = apicheck_resp


class StatusResource(object):
    def on_get(self, req, resp, vmid):
        """ check vm status """
        logger.info('grid> status ' + str(vmid))
        apicheck_stat, apicheck_resp = apicheck(req.params)
        if apicheck_stat:
            resp.status = falcon.HTTP_200
            try:
                resp.body = urllib.parse.urlencode(plugin.vmstatus(vmid))
            except:
                logger.error('grid> status error')
                raise
                resp.status = falcon.HTTP_403
                response = 'STATUS ERR'
                resp.body = response
        else:
            resp.status = falcon.HTTP_403
            resp.body = apicheck_resp


class DeleteResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ delete machine completely"""
        logger.info('grid> delete ' + str(vmid))
        apicheck_stat, apicheck_resp = apicheck(req.params)
        if apicheck_stat:
            try:
                resp.body = urllib.parse.urlencode(plugin.vmdelete(vmid))
            except:
                logger.error('grid> delete error')
                raise
                resp.status = falcon.HTTP_403
                response = 'DELETE ERR'
                resp.body = response
        else:
            resp.status = falcon.HTTP_403
            resp.body = apicheck_resp


class ArchivateResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ Temporary suspend the instance """
        logger.info('grid> suspend ' + str(vmid))
        apicheck_stat, apicheck_resp = apicheck(req.params)
        if apicheck_stat:
            resp.status = falcon.HTTP_202
            try:
                resp.body = urllib.parse.urlencode(plugin.vmsuspend(vmid))
            except:
                logger.error('grid> pause error')
                raise
                resp.status = falcon.HTTP_403
                response = 'PAUSE ERR'
                resp.body = response
        else:
            resp.status = falcon.HTTP_403
            resp.body = apicheck_resp


class UnArchiveResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ Unuspend the instance """
        logger.info('grid> resume ' + str(vmid))
        apicheck_stat, apicheck_resp = apicheck(req.params)
        if apicheck_stat:
            resp.status = falcon.HTTP_202
            try:
                resp.body = urllib.parse.urlencode(plugin.vmresume(vmid))
            except:
                logger.error('grid> resume error')
                raise
                resp.status = falcon.HTTP_403
                response = 'RESUME ERR'
                resp.body = response
        else:
            resp.status = falcon.HTTP_403
            resp.body = apicheck_resp


class StartResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ Start the instance """
        logger.info('grid> start ' + str(vmid))
        apicheck_stat, apicheck_resp = apicheck(req.params)
        if apicheck_stat:
            resp.status = falcon.HTTP_202
            try:
                resp.body = urllib.parse.urlencode(plugin.vmstart(vmid))
            except:
                logger.error('grid> start error')
                #raise
                resp.status = falcon.HTTP_403
                response = 'START ERR'
                resp.body = response
        else:
            resp.status = falcon.HTTP_403
            resp.body = apicheck_resp


class ShutdownResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ ACPI Shutdown the instance """
        logger.info('grid> shutdown ' + str(vmid))
        apicheck_stat, apicheck_resp = apicheck(req.params)
        if apicheck_stat:
            resp.status = falcon.HTTP_202
            try:
                resp.body = urllib.parse.urlencode(plugin.vmshutdown(vmid))
                #TODO: Try few times and then return proper status message
            except:
                logger.error('grid> shutdown error')
                #raise
                resp.status = falcon.HTTP_403
                response = 'SHUTDOWN ERR'
                resp.body = response
        else:
            resp.status = falcon.HTTP_403
            resp.body = apicheck_resp


class StopResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ Stop the instance """
        logger.info('grid> stop ' + str(vmid))
        apicheck_stat, apicheck_resp = apicheck(req.params)
        if apicheck_stat:
            resp.status = falcon.HTTP_202
            try:
                resp.body = urllib.parse.urlencode(plugin.vmstop(vmid))
            except:
                logger.error('grid> stop error')
                #raise
                resp.status = falcon.HTTP_403
                response = 'STOP ERR'
                resp.body = response
        else:
            resp.status = falcon.HTTP_403
            resp.body = apicheck_resp

class VNCResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ Create a VNC link to the instance """
        apicheck_stat, apicheck_resp = apicheck(req.params)
        logger.info('grid> vnc ' + str(vmid))
        if apicheck_stat:
            try:
                resp.status = falcon.HTTP_202
                resp.body = urllib.parse.urlencode(plugin.vmvnc(vmid))
            except:
                logger.error('grid> vnc error')
                raise
                resp.status = falcon.HTTP_403
                response = 'VNC ERR'
                resp.body = response
        else:
            resp.status = falcon.HTTP_403
            resp.body = apicheck_resp


if __name__ == '__main__':
    sys.exit("invoke proxmaster via uwsgi. thanks. bye. o/")

#setup routes
wsgi_app = api = application = falcon.API(middleware=[
    RequireJSON(),
    JSONTranslator(),
])
   
#display motd
welcome() 
#logger.info('grid> sync')
#grid.sync()

# setup routes
res_validate = ValidateResource()
api.add_route('/validate', res_validate)

res_cluster = ClusterResource()
api.add_route('/instance', res_cluster)

res_status = StatusResource()
api.add_route('/instance/{vmid}', res_status)

res_delete = DeleteResource()
api.add_route('/instance/delete/{vmid}', res_delete)

res_archivate = ArchivateResource()
api.add_route('/instance/archivate/{vmid}', res_archivate)

res_unarchive = UnArchiveResource()
api.add_route('/instance/unarchive/{vmid}', res_unarchive)

res_start = StartResource()
api.add_route('/instance/start/{vmid}', res_start)

res_shutdown = ShutdownResource()
api.add_route('/instance/shutdown/{vmid}', res_shutdown)

res_stop = StopResource()
api.add_route('/instance/stop/{vmid}', res_stop)

res_vnc = VNCResource()
api.add_route('/instance/vnc/{vmid}', res_vnc)