import json
import requests
import xmlrpclib

from urlparse import urlsplit


class LavaServerException(Exception):
    def __init__(self, url, status_code):
        self.status_code = int(status_code)
        message = "%s returned status code %d" % (url, self.status_code)
        super(Exception, self).__init__(message)


class LavaResponseException(Exception):
    pass


class LavaServerProxy():
    XMLRPC = 'RPC2/'
    def __init__(self, base_url, username=None, password=None):
        self.url = base_url
        self.username = username # API username
        self.password = password # API token
        self.xmlrpc_url = "https://" + base_url + "/" + LavaServerProxy.XMLRPC

    def test_results_available(self, job_id):
        status = self.call_xmlrpc('scheduler.job_status', job_id)
        return 'bundle_sha1' in status and len(status['bundle_sha1']) > 0

    def get_test_job_status(self, job_id):
        result = self.call_xmlrpc("scheduler.job_status", job_id)
        return result['job_status']

    def get_test_job_results(self, job_id):
        status = self.call_xmlrpc('scheduler.job_status', job_id)
        sha1 = status['bundle_sha1']
        result_bundle = self.call_xmlrpc('dashboard.get', sha1)
        bundle = json.loads(result_bundle['content'])
        return bundle

    def get_test_job_bundle_url(self, job_id):
        print "retrieving bundle for job: {0}".format(job_id)
        status = self.call_xmlrpc('scheduler.job_status', job_id)
        sha1 = status['bundle_sha1']
        content = self.call_xmlrpc('scheduler.job_details', job_id)
        definition = json.loads(content['definition'])
        for action in definition['actions']:
            if action['command'] == "submit_results" or \
                    action['command'] == "submit_results_on_host":
                if 'stream' in action['parameters'].keys() \
                        and 'server' in action['parameters'].keys():
                    return "{0}://{1}/dashboard/streams{2}bundles/{3}".format(
                            urlsplit(action['parameters']['server']).scheme,
                            urlsplit(action['parameters']['server']).netloc,
                            action['parameters']['stream'],
                            sha1
                        )
        return None

    def get_result_class_name(self, job_id):
        content = self.call_xmlrpc('scheduler.job_details', job_id)
        definition = json.loads(content['definition'])
        for action in definition['actions']:
            if action['command'] == "lava_test_shell":
                if 'testdef_repos' in action['parameters'].keys():
                    for test_repo in action['parameters']['testdef_repos']:
                        if 'testdef' in test_repo.keys():
                            if test_repo['testdef'].endswith("art-microbenchmarks.yaml"):
                                return "ArtMicrobenchmarksTestResults"
                            if test_repo['testdef'].endswith("wa2host_postprocessing.yaml"):
                                return "ArtWATestResults"
                            if test_repo['testdef'].endswith("lava-android-benchmark-host.yaml"):
                                return "AndroidMultinodeBenchmarkResults"
                            if test_repo['testdef'].endswith("application-benchmark-host.yaml"):
                                return "AndroidApplicationsBenchmarkResults"
                            if test_repo['testdef'].endswith("cts-host.yaml"):
                                return "AndroidCtsTestResults"
        return "GenericLavaTestSystem"

    def call_xmlrpc(self, method_name, *method_params):
        payload = xmlrpclib.dumps((method_params), method_name)

        response = requests.request('POST', self.xmlrpc_url,
                                    data = payload,
                                    headers = {'Content-Type': 'application/xml'},
                                    auth = (self.username, self.password),
                                    timeout = 100,
                                    stream = False)

        if response.status_code == 200:
            try:
                result = xmlrpclib.loads(response.content)[0][0]
                return result
            except xmlrpclib.Fault as e:
                message = "Fault code: %d, Fault string: %s\n %s" % (
                    e.faultCode, e.faultString, payload)
                raise LavaResponseException(message)
        else:
            raise LavaServerException(self.xmlrpc_url, response.status_code)