# -----------------------------------------------------------------------------
# Copyright (c) 2014--, The Qiita Development Team.
#
# Distributed under the terms of the BSD 3-clause License.
#
# The full license is in the file LICENSE, distributed with this software.
# -----------------------------------------------------------------------------

from json import loads

from tornado.web import HTTPError

import qiita_db as qdb
from .oauth2 import OauthBaseHandler, authenticate_oauth


def _get_job(job_id):
    """Returns the job with the given id if it exists

    Parameters
    ----------
    job_id : str
        The job id to check

    Returns
    -------
    qiita_db.processing_job.ProcessingJob
        The requested job

    Raises
    ------
    HTTPError
        If the job does not exist, with error code 404
        If there is a problem instantiating the processing job, with error
        code 500
    """
    if not qdb.processing_job.ProcessingJob.exists(job_id):
        raise HTTPError(404)

    try:
        job = qdb.processing_job.ProcessingJob(job_id)
    except Exception as e:
        raise HTTPError(500, reason='Error instantiating the job: %s' % str(e))

    return job


class JobHandler(OauthBaseHandler):
    @authenticate_oauth
    def get(self, job_id):
        """Get the job information

        Parameters
        ----------
        job_id : str
            The job id

        Returns
        -------
        dict
            {'command': str,
             'parameters': dict of {str, obj},
             'status': str}
             - command: the name of the command that the job executes
             - parameters: the parameters of the command, keyed by parameter
             name
             - status: the status of the job
        """
        with qdb.sql_connection.TRN:
            job = _get_job(job_id)
            cmd = job.command.name
            params = job.parameters.values
            status = job.status
            msg = '' if status != 'error' else job.log.msg

        response = {'command': cmd, 'parameters': params,
                    'status': status, 'msg': msg}

        self.write(response)


class HeartbeatHandler(OauthBaseHandler):
    @authenticate_oauth
    def post(self, job_id):
        """Update the heartbeat timestamp of the job

        Parameters
        ----------
        job_id : str
            The job id
        """
        with qdb.sql_connection.TRN:
            job = _get_job(job_id)

            try:
                job.update_heartbeat_state()
            except qdb.exceptions.QiitaDBOperationNotPermittedError as e:
                raise HTTPError(403, reason=str(e))

        self.finish()


class ActiveStepHandler(OauthBaseHandler):
    @authenticate_oauth
    def post(self, job_id):
        """Changes the current execution step of the given job

        Parameters
        ----------
        job_id : str
            The job id
        """
        with qdb.sql_connection.TRN:
            job = _get_job(job_id)
            payload = loads(self.request.body)
            step = payload['step']
            try:
                job.step = step
            except qdb.exceptions.QiitaDBOperationNotPermittedError as e:
                raise HTTPError(403, reason=str(e))

        self.finish()


class CompleteHandler(OauthBaseHandler):
    @authenticate_oauth
    def post(self, job_id):
        """Updates the job to one of the completed statuses: 'success', 'error'

        Parameters
        ----------
        job_id : str
            The job to complete
        """
        with qdb.sql_connection.TRN:
            job = _get_job(job_id)

            if job.status != 'running':
                raise HTTPError(
                    403, "Can't complete job: not in a running state")

            qiita_plugin = qdb.software.Software.from_name_and_version(
                'Qiita', 'alpha')
            cmd = qiita_plugin.get_command('complete_job')
            params = qdb.software.Parameters.load(
                cmd, values_dict={'job_id': job_id,
                                  'payload': self.request.body.decode(
                                      'ascii')})
            # complete_job are unique so it is fine to force them to be created
            job = qdb.processing_job.ProcessingJob.create(
                job.user, params, force=True)
            job.submit()

        self.finish()


class ProcessingJobAPItestHandler(OauthBaseHandler):
    @authenticate_oauth
    def post(self):
        user = self.get_argument('user', 'test@foo.bar')
        s_name, s_version, cmd_name = loads(self.get_argument('command'))
        params_dict = self.get_argument('parameters')
        status = self.get_argument('status', None)

        cmd = qdb.software.Software.from_name_and_version(
            s_name, s_version).get_command(cmd_name)

        params = qdb.software.Parameters.load(cmd, json_str=params_dict)

        job = qdb.processing_job.ProcessingJob.create(
            qdb.user.User(user), params, True)

        if status:
            job._set_status(status)

        self.write({'job': job.id})