from tornado.gen import coroutine, Task

from tornado.web import authenticated, HTTPError

import json

import ast

from .base_handlers import BaseHandler

from qiita_core.qiita_settings import r_client

from qiita_core.util import execute_as_transaction

commands = 'resources:commands'

default_col_name = "samples * columns"

class ResourcesHandler(BaseHandler):

    def check_admin(self):

        if self.current_user.level != "admin":

            raise HTTPError(403, reason="%s does not have access to portal "

                            "editing!" % self.current_user.id)

    @execute_as_transaction

    def _get_resources(self, cname, sname, version, col_name, callback):

        resources = {}

        vals = [

            ('img_mem', r_client.get),

            ('img_time', r_client.get),

            ('time', r_client.get),

            ('title_mem', r_client.get),

            ('title_time', r_client.get)

        ]

        for k, f in vals:

            redis_key = 'resources$#%s$#%s$#%s$#%s:%s' % (cname, sname,

                                                          version, col_name, k)

            resources[k] = f(redis_key)

        callback(resources)

    @execute_as_transaction

    def _get_commands(self, callback):

        res = r_client.get(commands)

        callback(res)

    @authenticated

    @coroutine

    @execute_as_transaction

    def get(self):

        self.check_admin()

        commands = yield Task(self._get_commands)

        commands_str = commands.decode('utf-8')

        commands_dict = ast.literal_eval(commands_str)

        commands_json = json.dumps(commands_dict)

        self.render('resources.html',

                    img_mem=None, img_time=None,

                    time=None,

                    mk=None, ma=None, mb=None,

                    mmodel=None, mreal=None,

                    mcalc=None, mfail=None,

                    tk=None, ta=None, tb=None,

                    tmodel=None, treal=None,

                    tcalc=None, tfail=None,

                    commands=commands_json,

                    initial_load=True)

    @authenticated

    @coroutine

    @execute_as_transaction

    def post(self):

        try:

            data = json.loads(self.request.body)

            software = data.get('software')

            version = data.get('version')

            command = data.get('command')

            resources = yield Task(self._get_resources, command, software,

                                   version, default_col_name)

            mcof, mmodel, mreal, mcalc, mfail = list(

                map(lambda x: x.split(b": ")[1].strip().decode('utf-8'),

                    resources['title_mem'].split(b"\n")))

            tcof, tmodel, treal, tcalc, tfail = list(

                map(lambda x: x.split(b": ")[1].strip().decode('utf-8'),

                    resources['title_time'].split(b"\n")))

            mk, ma, mb = mcof.split("||")

            tk, ta, tb = tcof.split("||")

            response_data = {

                "status": "success",

                "img_mem": resources[

                    'img_mem'].decode('utf-8') if isinstance(

                    resources['img_mem'], bytes) else resources['img_mem'],

                "img_time": resources[

                    'img_time'].decode('utf-8') if isinstance(

                    resources['img_time'], bytes) else resources['img_time'],

                "time": resources[

                    'time'].decode('utf-8') if isinstance(

                    resources['time'], bytes) else resources['time'],

                "mk": mk, "ma": ma, "mb": mb,

                "tk": tk, "ta": ta, "tb": tb,

                "mmodel": mmodel, "mreal": mreal,

                "mcalc": mcalc, "mfail": mfail,

                "tcof": tcof,

                "tmodel": tmodel, "treal": treal,

                "tcalc": tcalc, "tfail": tfail,

                "initial_load": False

            }

            self.write(json.dumps(response_data) + "\n")

        except json.JSONDecodeError:

            self.set_status(400)

            self.finish({"error": "Invalid JSON data"})

        except Exception as e:

            import traceback

            print(traceback.format_exc())

            if resources['title_mem'] is None:

                response_data = {

                    "status": "no_data",

                    "img_mem": None,

                    "img_time": None,

                    "time": None,

                    "mk": None, "ma": None, "mb": None,

                    "tk": None, "ta": None, "tb": None,

                    "mmodel": None, "mreal": None,

                    "mcalc": None, "mfail": None,

                    "tcof": None,

                    "tmodel": None, "treal": None,

                    "tcalc": None, "tfail": None,

                    "initial_load": False

                }

                self.set_status(200)

                self.write(json.dumps(response_data) + "\n")

            else:

                self.set_status(500)

                self.finish({"error": str(e)})